Add scripts

scripts/finish.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Full remaining pipeline, run sequentially so nothing competes for the GPU.
+# Idempotent: run_experiments skips configs whose summary.json already exists.
+set -u
+cd /root/al
+export PYTHONPATH=src
+LOG=results/logs
+
+echo "[finish] $(date +%H:%M:%S) main grid ..."
+python scripts/run_experiments.py --grid main --device cuda >> "$LOG/main_grid.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) ablation grid ..."
+python scripts/run_experiments.py --grid ablation --device cuda >> "$LOG/ablation_grid.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) confound analysis ..."
+python src/trifuse/analysis/confound.py data/metadata/subjects_clean.csv \
+    results/tables/confound >> "$LOG/analysis.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) subgroup analysis (main-grid OOF) ..."
+python - >> "$LOG/analysis.log" 2>&1 <<'PY'
+import sys, glob; sys.path.insert(0, "src")
+from pathlib import Path
+from trifuse.analysis.subgroup import run_subgroup
+oof = {Path(p).parent.name: p for p in glob.glob("results/*/oof.csv")}
+print("subgroup over:", sorted(oof))
+run_subgroup(oof, "data/metadata/subjects_clean.csv", "results/tables/subgroup")
+PY
+
+echo "[finish] $(date +%H:%M:%S) tables ..."
+python scripts/make_tables.py >> "$LOG/tables.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) figures ..."
+python scripts/make_figures.py >> "$LOG/figures.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) interpretability (Grad-CAM) ..."
+python scripts/make_interpret.py >> "$LOG/interpret.log" 2>&1
+
+echo "[finish] $(date +%H:%M:%S) DONE"

scripts/make_figures.py

@@ -0,0 +1,181 @@
+"""Render the paper's figures from results/<name>/ OOF predictions and summaries.
+
+Figures (saved under results/figures/):
+  fig_main_comparison.png   Macro-F1 mean±std bar chart across all models
+  fig_confusion_<name>.png  pooled 3x3 confusion matrix (row-normalized) per model
+  fig_roc_<name>.png        one-vs-rest ROC curves (CN/VMD/AD) per model
+  fig_subgroup.png          Macro-F1 by age band and sex for the strongest models
+
+All figures are regenerated deterministically from saved OOF preds; no re-training.
+Models without a summary.json yet are silently skipped, so this can run while the
+grid is still in progress.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+from sklearn.metrics import roc_curve, auc  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+RESULTS = ROOT / "results"
+FIGURES = RESULTS / "figures"
+SUBJECTS_CSV = ROOT / "data/metadata/subjects_clean.csv"
+
+from trifuse.eval.metrics import CLASS_NAMES, confusion  # noqa: E402
+from trifuse.analysis.subgroup import subgroup_table  # noqa: E402
+
+# display order + labels (same keys as make_tables.MAIN_ORDER)
+MODELS = [
+    ("xgboost", "XGBoost"),
+    ("tabular_mlp", "MLP"),
+    ("resnet50", "ResNet50"),
+    ("densenet2p5d", "DenseNet121"),
+    ("resnet3d", "3D ResNet18"),
+    ("vit_b16", "ViT-B/16"),
+    ("swin3d", "3D Swin-T"),
+    ("hcct", "3D HCCT"),
+    ("vswin_lite", "VSwinFormer-lite"),
+    ("densenet_latefusion", "DenseNet+concat"),
+    ("trifuse_ad", "TriFuse-AD"),
+]
+PROB_COLS = ["prob_0", "prob_1", "prob_2"]
+
+
+def _summary(name):
+    p = RESULTS / name / "summary.json"
+    return json.loads(p.read_text()) if p.exists() else None
+
+
+def _oof(name):
+    p = RESULTS / name / "oof.csv"
+    return pd.read_csv(p) if p.exists() else None
+
+
+def fig_main_comparison():
+    names, means, stds = [], [], []
+    for key, disp in MODELS:
+        s = _summary(key)
+        if s is None:
+            continue
+        m = s["summary"]["macro_f1"]
+        names.append(disp)
+        means.append(m["mean"] * 100)
+        stds.append(m["std"] * 100)
+    if not names:
+        return
+    colors = ["#4c72b0"] * len(names)
+    if "TriFuse-AD" in names:
+        colors[names.index("TriFuse-AD")] = "#c44e52"
+    fig, ax = plt.subplots(figsize=(10, 5))
+    y = np.arange(len(names))
+    ax.barh(y, means, xerr=stds, color=colors, capsize=3, alpha=0.9)
+    ax.set_yticks(y)
+    ax.set_yticklabels(names)
+    ax.invert_yaxis()
+    ax.set_xlabel("Macro-F1 (%)  — mean ± std over 15 runs")
+    ax.set_title("Three-stage classification (CN / VMD / AD), OASIS-1 age≥60")
+    ax.grid(axis="x", alpha=0.3)
+    for yi, mv in zip(y, means):
+        ax.text(mv + 1, yi, f"{mv:.1f}", va="center", fontsize=8)
+    fig.tight_layout()
+    fig.savefig(FIGURES / "fig_main_comparison.png", dpi=150)
+    plt.close(fig)
+
+
+def fig_confusion(name, disp):
+    oof = _oof(name)
+    if oof is None:
+        return
+    cm = confusion(oof["y_true"].to_numpy(), oof["y_pred"].to_numpy())
+    cmn = cm / cm.sum(axis=1, keepdims=True).clip(min=1)
+    fig, ax = plt.subplots(figsize=(4.2, 3.8))
+    im = ax.imshow(cmn, cmap="Blues", vmin=0, vmax=1)
+    ax.set_xticks(range(3)); ax.set_yticks(range(3))
+    ax.set_xticklabels(CLASS_NAMES); ax.set_yticklabels(CLASS_NAMES)
+    ax.set_xlabel("Predicted"); ax.set_ylabel("True")
+    ax.set_title(f"{disp} (pooled 15 runs)")
+    for i in range(3):
+        for j in range(3):
+            ax.text(j, i, f"{cmn[i, j]:.2f}\n({cm[i, j]})", ha="center", va="center",
+                    color="white" if cmn[i, j] > 0.5 else "black", fontsize=8)
+    fig.colorbar(im, ax=ax, fraction=0.046)
+    fig.tight_layout()
+    fig.savefig(FIGURES / f"fig_confusion_{name}.png", dpi=150)
+    plt.close(fig)
+
+
+def fig_roc(name, disp):
+    oof = _oof(name)
+    if oof is None or not set(PROB_COLS).issubset(oof.columns):
+        return
+    y = oof["y_true"].to_numpy()
+    prob = oof[PROB_COLS].to_numpy()
+    fig, ax = plt.subplots(figsize=(4.5, 4.2))
+    for c, cname in enumerate(CLASS_NAMES):
+        yc = (y == c).astype(int)
+        if yc.sum() == 0:
+            continue
+        fpr, tpr, _ = roc_curve(yc, prob[:, c])
+        ax.plot(fpr, tpr, label=f"{cname} (AUC={auc(fpr, tpr):.2f})")
+    ax.plot([0, 1], [0, 1], "k--", alpha=0.4)
+    ax.set_xlabel("False positive rate"); ax.set_ylabel("True positive rate")
+    ax.set_title(f"{disp} — one-vs-rest ROC")
+    ax.legend(loc="lower right", fontsize=8)
+    fig.tight_layout()
+    fig.savefig(FIGURES / f"fig_roc_{name}.png", dpi=150)
+    plt.close(fig)
+
+
+def fig_subgroup():
+    """Macro-F1 by age band / sex for the models that have OOF, focused on the strongest."""
+    if not SUBJECTS_CSV.exists():
+        return
+    have = [(k, d) for k, d in MODELS if (RESULTS / k / "oof.csv").exists()]
+    # prefer TriFuse-AD + best MRI-only + a tabular shortcut, if present
+    pick = [kd for kd in have if kd[0] in {"trifuse_ad", "resnet3d", "xgboost", "densenet_latefusion"}]
+    pick = pick or have[:3]
+    if not pick:
+        return
+    subgroups = ["Overall", "60-69", "70-79", "80+", "Male", "Female"]
+    fig, ax = plt.subplots(figsize=(9, 4.5))
+    width = 0.8 / len(pick)
+    x = np.arange(len(subgroups))
+    for i, (key, disp) in enumerate(pick):
+        t = subgroup_table(RESULTS / key / "oof.csv", SUBJECTS_CSV).set_index("subgroup")
+        vals = [t.loc[g, "macro_f1"] * 100 if g in t.index and "macro_f1" in t.columns
+                and not pd.isna(t.loc[g, "macro_f1"]) else 0 for g in subgroups]
+        ax.bar(x + i * width, vals, width, label=disp)
+    ax.set_xticks(x + width * (len(pick) - 1) / 2)
+    ax.set_xticklabels(subgroups)
+    ax.set_ylabel("Macro-F1 (%)")
+    ax.set_title("Subgroup robustness (pooled OOF)")
+    ax.legend(fontsize=8)
+    ax.grid(axis="y", alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(FIGURES / "fig_subgroup.png", dpi=150)
+    plt.close(fig)
+
+
+def main():
+    FIGURES.mkdir(parents=True, exist_ok=True)
+    fig_main_comparison()
+    for key, disp in MODELS:
+        fig_confusion(key, disp)
+        fig_roc(key, disp)
+    fig_subgroup()
+    made = sorted(p.name for p in FIGURES.glob("*.png"))
+    print(f"wrote {len(made)} figures to {FIGURES}:")
+    for m in made:
+        print(" ", m)
+
+
+if __name__ == "__main__":
+    main()

scripts/make_interpret.py

@@ -0,0 +1,177 @@
+"""P11 interpretability: train TriFuse-AD on one representative fold, then run
+Grad-CAM on the shared CNN encoder for a few correct + incorrect test cases.
+
+Qualitative only. We do NOT claim the model localizes specific structures; we
+report that attended regions overlap with anatomy known to be relevant in AD
+(medial temporal lobe, ventricles, cortical atrophy).
+
+Needs the GPU, so run this AFTER the main grid finishes (TriFuse-AD is the last
+config in the grid and holds the GPU until then).
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+RESULTS = ROOT / "results"
+FIGURES = RESULTS / "figures"
+SUBJECTS_CSV = ROOT / "data/metadata/subjects_clean.csv"
+
+from trifuse.data.datasets import SliceDataset, collate, fit_tab_stats  # noqa: E402
+from trifuse.data.splits import make_folds, split_for  # noqa: E402
+from trifuse.models.registry import build_model  # noqa: E402
+from trifuse.training.config import TrainConfig  # noqa: E402
+from trifuse.training.trainer import fit  # noqa: E402
+from trifuse.analysis.gradcam import GradCAM, overlay_heatmap  # noqa: E402
+from trifuse.eval.metrics import CLASS_NAMES  # noqa: E402
+from torch.utils.data import DataLoader  # noqa: E402
+
+TRI = ("axial", "coronal", "sagittal")
+SEED, FOLD = 7, 0
+
+
+class _SlicesOnly(nn.Module):
+    """Adapt TriFuse-AD's (slices, tab) forward to the single-input API Grad-CAM expects."""
+
+    def __init__(self, model: nn.Module, tab: torch.Tensor):
+        super().__init__()
+        self.model = model
+        self.tab = tab
+
+    def forward(self, slices: torch.Tensor) -> torch.Tensor:
+        return self.model(slices, self.tab)
+
+
+def _target_layer(model: nn.Module) -> nn.Module:
+    """Last conv stage of the timm ConvNeXt encoder (outputs B,C,H,W)."""
+    enc = model.encoder
+    if hasattr(enc, "stages"):
+        return enc.stages[-1]
+    # fallback: last Conv2d
+    convs = [m for m in enc.modules() if isinstance(m, nn.Conv2d)]
+    return convs[-1]
+
+
+def _train_fold(device: str) -> tuple[nn.Module, pd.DataFrame, dict, TrainConfig]:
+    df = pd.read_csv(SUBJECTS_CSV)
+    folds = make_folds(df)
+    tr, va, te = split_for(folds, df, SEED, FOLD)
+    train_df = df[df.subject_id.isin(tr)]
+    val_df = df[df.subject_id.isin(va)]
+    test_df = df[df.subject_id.isin(te)]
+
+    cfg = TrainConfig(name="trifuse_interp", model="trifuse", modality="multimodal",
+                      n_slices=9, planes=TRI, epochs=70, batch_size=6,
+                      lr=3e-4, backbone_lr=3e-5, freeze_epochs=6, seed=SEED)
+    tab_stats = fit_tab_stats(train_df, cfg.tab_features)
+    counts = np.bincount(train_df["class_id"], minlength=3).tolist()
+
+    def loader(sub, shuffle, aug):
+        ds = SliceDataset(sub, cfg.tab_features, tab_stats, planes=TRI,
+                          n_slices=cfg.n_slices, modality="multimodal", augment=aug)
+        return DataLoader(ds, batch_size=cfg.batch_size, shuffle=shuffle,
+                          num_workers=cfg.num_workers, collate_fn=collate, pin_memory=True)
+
+    model = build_model(cfg, n_tab_features=len(cfg.tab_features), pretrained=True)
+    fit(model, loader(train_df, True, True), loader(val_df, False, False),
+        cfg, counts, device=device)
+    return model, test_df, tab_stats, cfg
+
+
+def _gradcam_for_subject(model, target, batch, device, n_slices, planes):
+    """Return {plane: (gray_center, heat_center)} for the argmax class, center slice per plane.
+
+    TriFuse-AD flattens the 27 slices into the CNN batch dim, so the target layer's
+    captured activations/grads are (T, C, H', W') — one per slice. We compute a
+    per-token Grad-CAM here rather than using GradCAM.__call__'s single-map return.
+    """
+    import torch.nn.functional as F
+    slices = batch["slices"].to(device)          # (1, T, 3, H, W)
+    tab = batch["tab"].to(device)
+    wrapper = _SlicesOnly(model, tab)
+    cam = GradCAM(wrapper, target)
+    _ = cam(slices, class_idx=None)               # triggers fwd+bwd, fills cam._acts/_grads
+    acts, grads = cam._acts, cam._grads           # (T, C, H', W')
+    cam.remove()
+
+    H, W = slices.shape[-2:]
+    weights = grads.mean(dim=(2, 3), keepdim=True)         # (T, C, 1, 1)
+    heat = F.relu((weights * acts).sum(dim=1))             # (T, H', W')
+    heat = F.interpolate(heat.unsqueeze(1), size=(H, W), mode="bilinear",
+                         align_corners=False)[:, 0]        # (T, H, W)
+    heat = heat.detach().cpu().numpy()
+
+    out = {}
+    center = n_slices // 2
+    for p_idx, plane in enumerate(planes):
+        tok = p_idx * n_slices + center
+        gray = slices[0, tok, 0].detach().cpu().numpy()
+        h = heat[tok]
+        h = (h - h.min()) / (np.ptp(h) + 1e-8)             # per-slice normalize
+        out[plane] = (gray, h)
+    return out
+
+
+def main():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    FIGURES.mkdir(parents=True, exist_ok=True)
+    print(f"training TriFuse-AD on seed={SEED} fold={FOLD} ({device}) for interpretability...",
+          flush=True)
+    model, test_df, tab_stats, cfg = _train_fold(device)
+    model.eval()
+    target = _target_layer(model)
+
+    ds = SliceDataset(test_df, cfg.tab_features, tab_stats, planes=TRI,
+                      n_slices=cfg.n_slices, modality="multimodal", augment=False)
+    dl = DataLoader(ds, batch_size=1, shuffle=False, collate_fn=collate)
+
+    cases = []  # (subject_id, y_true, y_pred, {plane:(gray,heat)})
+    for batch in dl:
+        with torch.no_grad():
+            logits = model(batch["slices"].to(device), batch["tab"].to(device))
+            pred = int(logits.argmax(1)[0])
+        yt = int(batch["y"][0])
+        maps = _gradcam_for_subject(model, target, batch, device, cfg.n_slices, TRI)
+        cases.append((batch["subject_id"][0], yt, pred, maps))
+
+    correct = [c for c in cases if c[1] == c[2]][:6]
+    wrong = [c for c in cases if c[1] != c[2]][:3]
+    picked = correct + wrong
+    if not picked:
+        print("no test cases produced; aborting figure")
+        return
+
+    n = len(picked)
+    fig, axes = plt.subplots(n, 3, figsize=(9, 3 * n))
+    if n == 1:
+        axes = axes[None, :]
+    for r, (sid, yt, yp, maps) in enumerate(picked):
+        tag = "OK" if yt == yp else "WRONG"
+        for c, plane in enumerate(TRI):
+            gray, heat = maps[plane]
+            axes[r, c].imshow(overlay_heatmap(gray, heat))
+            axes[r, c].axis("off")
+            if c == 0:
+                axes[r, c].set_ylabel(f"{sid}\nT:{CLASS_NAMES[yt]} P:{CLASS_NAMES[yp]} [{tag}]",
+                                      fontsize=8, rotation=0, ha="right", va="center")
+            axes[r, c].set_title(plane if r == 0 else "", fontsize=9)
+    fig.suptitle("TriFuse-AD Grad-CAM (shared CNN encoder, center slice per plane)")
+    fig.tight_layout()
+    out = FIGURES / "fig_gradcam_trifuse.png"
+    fig.savefig(out, dpi=150)
+    plt.close(fig)
+    print(f"wrote {out}  ({len(correct)} correct + {len(wrong)} wrong cases)")
+
+
+if __name__ == "__main__":
+    main()

scripts/make_tables.py

@@ -0,0 +1,165 @@
+"""Assemble the paper's result tables from results/<name>/ outputs.
+
+Table 3: main comparison (mean±std over 15 runs + bootstrap CI on Macro-F1).
+Table 3b: per-class F1 / recall.
+Table 4: ablation (A1-A5 + full).
+Significance: paired permutation test, TriFuse-AD vs best baseline, on per-run Macro-F1.
+
+Outputs CSV + a markdown rendering under results/tables/.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+RESULTS = ROOT / "results"
+TABLES = RESULTS / "tables"
+
+from trifuse.eval.stats import paired_permutation_test  # noqa: E402
+
+# display order + grouping for the main table
+MAIN_ORDER = [
+    ("Metadata", "xgboost", "XGBoost", "Tabular"),
+    ("Metadata", "tabular_mlp", "MLP", "Tabular"),
+    ("CNN", "resnet50", "ResNet50", "2D"),
+    ("CNN", "densenet2p5d", "DenseNet121", "2.5D"),
+    ("CNN", "resnet3d", "3D ResNet18", "3D"),
+    ("Transformer", "vit_b16", "ViT-B/16", "2.5D"),
+    ("Transformer", "swin3d", "3D Swin-T", "3D"),
+    ("Hybrid", "hcct", "3D HCCT", "3D"),
+    ("Hybrid", "vswin_lite", "CNN-VSwinFormer-lite", "3D"),
+    ("Multimodal", "densenet_latefusion", "DenseNet + concat", "MRI+tab"),
+    ("Proposed", "trifuse_ad", "TriFuse-AD", "MRI+tab"),
+]
+
+METRIC_COLS = ["accuracy", "balanced_accuracy", "macro_precision",
+               "macro_recall", "macro_f1", "macro_auc"]
+PERCLASS_COLS = ["f1_CN", "f1_VMD", "f1_AD", "recall_CN", "recall_VMD", "recall_AD"]
+
+
+def _load(name):
+    p = RESULTS / name / "summary.json"
+    if not p.exists():
+        return None
+    return json.loads(p.read_text())
+
+
+def _runs(name):
+    p = RESULTS / name / "runs.json"
+    return json.loads(p.read_text()) if p.exists() else None
+
+
+def _fmt(summary, key):
+    s = summary["summary"].get(key)
+    if not s:
+        return "-"
+    return f"{s['mean']*100:.1f}±{s['std']*100:.1f}"
+
+
+def build_main_table():
+    rows = []
+    for group, name, disp, inp in MAIN_ORDER:
+        s = _load(name)
+        if s is None:
+            rows.append({"Group": group, "Method": disp, "Input": inp,
+                         **{c: "-" for c in METRIC_COLS}})
+            continue
+        row = {"Group": group, "Method": disp, "Input": inp}
+        for c in METRIC_COLS:
+            row[c] = _fmt(s, c)
+        ci = s.get("macro_f1_bootstrap", {})
+        row["macro_f1_CI"] = (f"[{ci['ci_lo']*100:.1f}, {ci['ci_hi']*100:.1f}]"
+                              if ci else "-")
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+
+def build_perclass_table():
+    rows = []
+    for group, name, disp, inp in MAIN_ORDER:
+        s = _load(name)
+        if s is None:
+            continue
+        row = {"Method": disp}
+        for c in PERCLASS_COLS:
+            v = s["summary"].get(c)
+            row[c] = f"{v['mean']*100:.1f}±{v['std']*100:.1f}" if v else "-"
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+
+def build_ablation_table():
+    order = [
+        ("abl_A1_axial", "A1: axial-only"),
+        ("abl_A2_meanpool", "A2: mean-pool (no Transformer)"),
+        ("abl_A3_nometa", "A3: no metadata"),
+        ("abl_A4_concat", "A4: concat (no gate)"),
+        ("abl_A5_weightedce", "A5: weighted-CE"),
+        ("abl_full", "Full TriFuse-AD"),
+    ]
+    rows = []
+    for name, disp in order:
+        s = _load(name)
+        if s is None:
+            rows.append({"Variant": disp, "macro_f1": "-", "balanced_accuracy": "-", "f1_AD": "-"})
+            continue
+        rows.append({"Variant": disp, "macro_f1": _fmt(s, "macro_f1"),
+                     "balanced_accuracy": _fmt(s, "balanced_accuracy"),
+                     "f1_AD": _fmt(s, "f1_AD")})
+    return pd.DataFrame(rows)
+
+
+def significance():
+    """Paired permutation test: TriFuse-AD vs best non-proposed baseline (per-run Macro-F1)."""
+    prop = _runs("trifuse_ad")
+    if prop is None:
+        return None
+    prop_f1 = [r["macro_f1"] for r in prop]
+    best_name, best_mean, best_f1 = None, -1, None
+    for _, name, _, _ in MAIN_ORDER:
+        if name == "trifuse_ad":
+            continue
+        r = _runs(name)
+        if r is None:
+            continue
+        f1 = [x["macro_f1"] for x in r]
+        if np.mean(f1) > best_mean:
+            best_mean, best_name, best_f1 = np.mean(f1), name, f1
+    if best_f1 is None:
+        return None
+    p = paired_permutation_test(prop_f1, best_f1)
+    return {"proposed_mean": float(np.mean(prop_f1)), "best_baseline": best_name,
+            "best_baseline_mean": float(best_mean),
+            "delta": float(np.mean(prop_f1) - best_mean), "p_value": p}
+
+
+def main():
+    TABLES.mkdir(parents=True, exist_ok=True)
+    t3 = build_main_table()
+    t3b = build_perclass_table()
+    t4 = build_ablation_table()
+    t3.to_csv(TABLES / "table3_main.csv", index=False)
+    t3b.to_csv(TABLES / "table3b_perclass.csv", index=False)
+    t4.to_csv(TABLES / "table4_ablation.csv", index=False)
+
+    md = ["# Table 3 — Main comparison\n", t3.to_markdown(index=False),
+          "\n\n# Table 3b — Per-class F1 / Recall\n", t3b.to_markdown(index=False),
+          "\n\n# Table 4 — Ablation\n", t4.to_markdown(index=False)]
+    sig = significance()
+    if sig:
+        md.append(f"\n\n# Significance\nTriFuse-AD {sig['proposed_mean']*100:.1f} vs "
+                  f"{sig['best_baseline']} {sig['best_baseline_mean']*100:.1f} "
+                  f"(Δ={sig['delta']*100:+.1f}, permutation p={sig['p_value']:.4f})")
+        (TABLES / "significance.json").write_text(json.dumps(sig, indent=2))
+    (TABLES / "tables.md").write_text("\n".join(md))
+    print("\n".join(md))
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_data.py

@@ -0,0 +1,92 @@
+"""End-to-end data preparation: extract discs -> build cohort -> preprocess.
+
+Usage:
+    python scripts/prepare_data.py --extract      # extract all discs (idempotent)
+    python scripts/prepare_data.py --cohort       # build subjects_clean.csv + stats
+    python scripts/prepare_data.py --preprocess   # 3D volumes + 2.5D slices
+    python scripts/prepare_data.py --splits       # repeated stratified folds
+    python scripts/prepare_data.py --all          # everything in order
+"""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+RAW = ROOT / "data" / "raw"
+META = ROOT / "data" / "metadata"
+
+
+def extract_discs() -> None:
+    """Extract every disc tarball into data/raw/ (skips already-extracted)."""
+    discs = sorted(RAW.glob("oasis_cross-sectional_disc*.tar.gz"))
+    if not discs:
+        sys.exit("no disc tarballs found in data/raw/")
+    for tgz in discs:
+        n = tgz.name.split("disc")[1].split(".")[0]
+        marker = RAW / f"disc{n}"
+        if marker.exists():
+            print(f"disc{n}: already extracted")
+            continue
+        print(f"disc{n}: verifying gzip ...", flush=True)
+        r = subprocess.run(["gzip", "-t", str(tgz)], capture_output=True)
+        if r.returncode != 0:
+            print(f"  disc{n} CORRUPT: {r.stderr.decode()[:200]}", flush=True)
+            continue
+        print(f"disc{n}: extracting ...", flush=True)
+        subprocess.run(["tar", "xzf", str(tgz), "-C", str(RAW)], check=True)
+    print("extraction done")
+
+
+def build_cohort() -> None:
+    from trifuse.data.cohort import build_cohort as _bc
+    _bc(RAW, META)
+
+
+def preprocess() -> None:
+    from trifuse.data.preprocess_3d import run as run3d
+    from trifuse.data.preprocess_2d import run as run2d
+    csv = META / "subjects_clean.csv"
+    if not csv.exists():
+        sys.exit("run --cohort first (subjects_clean.csv missing)")
+    run3d(csv, ROOT / "data" / "processed_3d")
+    run2d(csv, ROOT / "data" / "processed_2d")
+
+
+def make_splits() -> None:
+    import pandas as pd
+    from trifuse.data.splits import make_folds
+    csv = META / "subjects_clean.csv"
+    df = pd.read_csv(csv)
+    folds = make_folds(df)
+    out = META / "folds.csv"
+    folds.to_csv(out, index=False)
+    print(f"wrote {out} ({len(folds)} rows = {folds['seed'].nunique()} seeds x {len(df)} subjects)")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--extract", action="store_true")
+    ap.add_argument("--cohort", action="store_true")
+    ap.add_argument("--preprocess", action="store_true")
+    ap.add_argument("--splits", action="store_true")
+    ap.add_argument("--all", action="store_true")
+    a = ap.parse_args()
+    if a.all or a.extract:
+        extract_discs()
+    if a.all or a.cohort:
+        build_cohort()
+    if a.all or a.preprocess:
+        preprocess()
+    if a.all or a.splits:
+        make_splits()
+    if not any([a.extract, a.cohort, a.preprocess, a.splits, a.all]):
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    main()

scripts/run_experiments.py

@@ -0,0 +1,61 @@
+"""Run the experiment grid: main models, ablation, or a named subset.
+
+Usage:
+    python scripts/run_experiments.py --grid main            # all 11 main configs
+    python scripts/run_experiments.py --grid ablation        # A1-A5 + full
+    python scripts/run_experiments.py --only xgboost resnet50 # named subset
+    python scripts/run_experiments.py --grid main --device cuda
+
+Each config runs the full 15-evaluation CV (3 seeds x 5 folds); OOF predictions and
+per-run metrics land in results/<name>/. Idempotent: skips configs whose summary.json
+already exists unless --force.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import traceback
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from trifuse.experiments import main_grid, ablation_grid
+from trifuse.eval.runner import run_experiment, RESULTS
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--grid", choices=["main", "ablation"], default=None)
+    ap.add_argument("--only", nargs="+", default=None, help="run only these config names")
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--force", action="store_true", help="rerun even if summary.json exists")
+    a = ap.parse_args()
+
+    configs = []
+    if a.grid == "main":
+        configs += main_grid()
+    if a.grid == "ablation":
+        configs += ablation_grid()
+    if not a.grid:
+        configs = main_grid() + ablation_grid()
+    if a.only:
+        configs = [c for c in configs if c.name in set(a.only)]
+    if not configs:
+        sys.exit("no configs selected")
+
+    print(f"running {len(configs)} configs: {[c.name for c in configs]}", flush=True)
+    for cfg in configs:
+        done = (RESULTS / cfg.name / "summary.json").exists()
+        if done and not a.force:
+            print(f"[skip] {cfg.name} (summary.json exists)", flush=True)
+            continue
+        print(f"\n===== {cfg.name} ({cfg.model}, {cfg.modality}) =====", flush=True)
+        try:
+            run_experiment(cfg, device=a.device)
+        except Exception:  # noqa: BLE001 - keep the grid going, log the failure
+            print(f"[FAIL] {cfg.name}:\n{traceback.format_exc()}", flush=True)
+
+
+if __name__ == "__main__":
+    main()