Add src

src/trifuse/analysis/confound.py

@@ -0,0 +1,112 @@
+"""Demographic confound & shortcut-baseline analysis (P10, Table 5 part 1).
+
+Purpose: show how much of the 3-class signal is recoverable from demographics /
+morphometry ALONE (no MRI). If an age-only model is already strong, the dataset
+has confounding that must be discussed honestly rather than hidden.
+
+Shortcut baselines:
+  - age-only logistic regression
+  - demographic XGBoost (age, sex, education, ses)
+  - full-structured XGBoost (demographic + eTIV, nWBV, ASF)
+
+All evaluated on the SAME subject-level folds/seeds as the main experiments,
+using out-of-fold predictions so numbers are directly comparable to Table 3.
+Never uses CDR or MMSE (label leakage).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import StandardScaler
+
+from trifuse.data.splits import make_folds, split_for, SEEDS, N_FOLDS
+from trifuse.eval.metrics import compute_metrics
+from trifuse.models.baselines_tab import make_xgb
+
+DEMO_COLS = ["age", "sex", "education", "ses"]
+FULL_COLS = ["age", "sex", "education", "ses", "etiv", "nwbv", "asf"]
+
+
+def _oof_predict(df: pd.DataFrame, feature_cols: list[str], model_kind: str) -> pd.DataFrame:
+    """Run repeated CV, return per-subject OOF predictions (one row per subject per seed)."""
+    folds = make_folds(df)
+    records = []
+    for seed in SEEDS:
+        for fold in range(N_FOLDS):
+            tr_ids, va_ids, te_ids = split_for(folds, df, seed, fold)
+            tr = df[df["subject_id"].isin(set(tr_ids) | set(va_ids))]
+            te = df[df["subject_id"].isin(te_ids)]
+
+            Xtr = tr[feature_cols].to_numpy(dtype=float)
+            ytr = tr["class_id"].to_numpy(dtype=int)
+            Xte = te[feature_cols].to_numpy(dtype=float)
+            yte = te["class_id"].to_numpy(dtype=int)
+
+            # impute (train medians) + standardize
+            med = np.nanmedian(Xtr, axis=0)
+            Xtr = np.where(np.isnan(Xtr), med, Xtr)
+            Xte = np.where(np.isnan(Xte), med, Xte)
+            sc = StandardScaler().fit(Xtr)
+            Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)
+
+            if model_kind == "logreg":
+                clf = LogisticRegression(max_iter=1000, class_weight="balanced")
+                clf.fit(Xtr, ytr)
+                prob = clf.predict_proba(Xte)
+            else:  # xgboost
+                clf = make_xgb(n_classes=3, seed=seed)
+                clf.fit(Xtr, ytr)
+                prob = clf.predict_proba(Xte)
+
+            pred = prob.argmax(1)
+            for sid, yt, yp, pr in zip(te_ids, yte, pred, prob):
+                records.append({"subject_id": sid, "seed": seed, "fold": fold,
+                                "y_true": int(yt), "y_pred": int(yp),
+                                "p0": pr[0], "p1": pr[1], "p2": pr[2]})
+    return pd.DataFrame(records)
+
+
+def run_confound(subjects_csv: str | Path, out_dir: str | Path) -> pd.DataFrame:
+    df = pd.read_csv(subjects_csv)
+    df = df[df["class_id"].notna()].reset_index(drop=True)
+    df["class_id"] = df["class_id"].astype(int)
+    out_dir = Path(out_dir); out_dir.mkdir(parents=True, exist_ok=True)
+
+    configs = [
+        ("age_only_logreg", ["age"], "logreg"),
+        ("demographic_xgb", DEMO_COLS, "xgboost"),
+        ("full_structured_xgb", FULL_COLS, "xgboost"),
+    ]
+    summary = []
+    for name, cols, kind in configs:
+        oof = _oof_predict(df, cols, kind)
+        oof.to_csv(out_dir / f"oof_{name}.csv", index=False)
+        # aggregate metric per seed then mean+/-std
+        per_seed = []
+        for seed in SEEDS:
+            s = oof[oof["seed"] == seed]
+            m = compute_metrics(s["y_true"].to_numpy(), s["y_pred"].to_numpy(),
+                                s[["p0", "p1", "p2"]].to_numpy())
+            per_seed.append(m)
+        macro_f1 = np.array([m["macro_f1"] for m in per_seed])
+        bal_acc = np.array([m["balanced_accuracy"] for m in per_seed])
+        ad_recall = np.array([m["recall_AD"] for m in per_seed])
+        summary.append({
+            "model": name,
+            "macro_f1_mean": macro_f1.mean(), "macro_f1_std": macro_f1.std(),
+            "bal_acc_mean": bal_acc.mean(), "bal_acc_std": bal_acc.std(),
+            "ad_recall_mean": ad_recall.mean(), "ad_recall_std": ad_recall.std(),
+        })
+    res = pd.DataFrame(summary)
+    res.to_csv(out_dir / "confound_summary.csv", index=False)
+    return res
+
+
+if __name__ == "__main__":
+    import sys
+    csv = sys.argv[1] if len(sys.argv) > 1 else "data/metadata/subjects_clean.csv"
+    out = sys.argv[2] if len(sys.argv) > 2 else "results/tables/confound"
+    print(run_confound(csv, out).to_string(index=False))

src/trifuse/analysis/gradcam.py

@@ -0,0 +1,92 @@
+"""Interpretability: Grad-CAM for 2D CNN encoders and attention rollout for the
+slice-plane Transformer in TriFuse-AD.
+
+Qualitative only. We do NOT claim the model "detects the hippocampus" - we report
+that attended regions overlap with anatomy known to be relevant in AD (medial
+temporal lobe, ventricles, cortical atrophy).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+class GradCAM:
+    """Grad-CAM on a target conv layer of a 2D CNN.
+
+    Usage:
+        cam = GradCAM(model, target_layer)
+        heat = cam(input_tensor, class_idx)   # (H, W) in [0,1]
+        cam.remove()
+    """
+
+    def __init__(self, model: torch.nn.Module, target_layer: torch.nn.Module):
+        self.model = model
+        self.target_layer = target_layer
+        self._acts: torch.Tensor | None = None
+        self._grads: torch.Tensor | None = None
+        self._fh = target_layer.register_forward_hook(self._fwd)
+        self._bh = target_layer.register_full_backward_hook(self._bwd)
+
+    def _fwd(self, _module, _inp, out):
+        self._acts = out.detach()
+
+    def _bwd(self, _module, _gin, gout):
+        self._grads = gout[0].detach()
+
+    def __call__(self, x: torch.Tensor, class_idx: int | None = None) -> np.ndarray:
+        self.model.eval()
+        logits = self.model(x)
+        if isinstance(logits, dict):
+            logits = logits["logits"]
+        if class_idx is None:
+            class_idx = int(logits.argmax(1)[0])
+        self.model.zero_grad(set_to_none=True)
+        logits[0, class_idx].backward(retain_graph=True)
+
+        # global-average-pool gradients -> channel weights
+        weights = self._grads.mean(dim=(2, 3), keepdim=True)  # (1,C,1,1)
+        cam = (weights * self._acts).sum(dim=1)               # (1,H',W')
+        cam = F.relu(cam)
+        cam = cam - cam.min()
+        cam = cam / (cam.max() + 1e-8)
+        cam = F.interpolate(cam.unsqueeze(1), size=x.shape[-2:], mode="bilinear",
+                            align_corners=False)[0, 0]
+        return cam.cpu().numpy()
+
+    def remove(self):
+        self._fh.remove()
+        self._bh.remove()
+
+
+@torch.no_grad()
+def attention_rollout(attn_maps: list[torch.Tensor]) -> np.ndarray:
+    """Attention rollout (Abnar & Zuidema 2020) over stacked attention matrices.
+
+    attn_maps: list of (heads, T, T) attention tensors from each Transformer layer.
+    Returns the CLS->token attention (T-1,) after rollout, normalized to [0,1].
+    """
+    result = None
+    for a in attn_maps:
+        a = a.mean(0)                       # average heads -> (T,T)
+        a = a + torch.eye(a.size(0), device=a.device)  # add residual
+        a = a / a.sum(dim=-1, keepdim=True)
+        result = a if result is None else a @ result
+    cls_to_tokens = result[0, 1:]           # CLS row, drop CLS->CLS
+    cls_to_tokens = cls_to_tokens - cls_to_tokens.min()
+    cls_to_tokens = cls_to_tokens / (cls_to_tokens.max() + 1e-8)
+    return cls_to_tokens.cpu().numpy()
+
+
+def overlay_heatmap(gray: np.ndarray, heat: np.ndarray, alpha: float = 0.45) -> np.ndarray:
+    """Overlay a [0,1] heatmap on a grayscale slice (both HxW) -> RGB uint8."""
+    import matplotlib
+
+    gray = (gray - gray.min()) / (np.ptp(gray) + 1e-8)
+    rgb = np.stack([gray] * 3, axis=-1)
+    cmap = matplotlib.colormaps["jet"](heat)[..., :3]
+    out = (1 - alpha) * rgb + alpha * cmap
+    return (np.clip(out, 0, 1) * 255).astype(np.uint8)

src/trifuse/analysis/subgroup.py

@@ -0,0 +1,76 @@
+"""Subgroup robustness analysis (P10, Table 5 part 2).
+
+Evaluates any model's saved OOF predictions sliced by demographic subgroup:
+age bands (60-69, 70-79, 80+) and sex. Tests whether a model's performance is
+stable across groups or driven by an age->label correlation.
+
+Consumes the per-subject OOF prediction CSVs written by eval/runner.py (columns:
+subject_id, seed, fold, y_true, y_pred, prob_0, prob_1, prob_2) joined to the
+cohort table for age/sex, so no re-training is needed.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from trifuse.eval.metrics import compute_metrics
+
+AGE_BANDS = [("60-69", 60, 70), ("70-79", 70, 80), ("80+", 80, 200)]
+
+
+def _band(age: float) -> str:
+    for name, lo, hi in AGE_BANDS:
+        if lo <= age < hi:
+            return name
+    return "other"
+
+
+def subgroup_table(oof_csv: str | Path, subjects_csv: str | Path) -> pd.DataFrame:
+    """Return per-subgroup metrics (pooled over all seeds/folds) for one model."""
+    oof = pd.read_csv(oof_csv)
+    sub = pd.read_csv(subjects_csv)[["subject_id", "age", "sex"]]
+    df = oof.merge(sub, on="subject_id", how="left")
+    df["age_band"] = df["age"].apply(_band)
+    df["sex_str"] = df["sex"].map({0: "Male", 1: "Female"}).fillna("Unknown")
+
+    prob_cols = ["prob_0", "prob_1", "prob_2"]
+
+    def _row(name: str, sl: pd.DataFrame) -> dict:
+        if len(sl) == 0:
+            return {"subgroup": name, "n": 0}
+        m = compute_metrics(sl["y_true"].to_numpy(), sl["y_pred"].to_numpy(),
+                            sl[prob_cols].to_numpy())
+        return {"subgroup": name, "n": int(sl["subject_id"].nunique()),
+                "macro_f1": m["macro_f1"], "balanced_accuracy": m["balanced_accuracy"],
+                "ad_recall": m["recall_AD"]}
+
+    rows = [_row("Overall", df)]
+    for name, _, _ in AGE_BANDS:
+        rows.append(_row(name, df[df["age_band"] == name]))
+    for sx in ["Male", "Female"]:
+        rows.append(_row(sx, df[df["sex_str"] == sx]))
+    return pd.DataFrame(rows)
+
+
+def run_subgroup(oof_csvs: dict[str, str | Path], subjects_csv: str | Path,
+                 out_dir: str | Path) -> pd.DataFrame:
+    """oof_csvs: {model_name: path}. Builds a combined subgroup table across models."""
+    out_dir = Path(out_dir); out_dir.mkdir(parents=True, exist_ok=True)
+    frames = []
+    for name, path in oof_csvs.items():
+        t = subgroup_table(path, subjects_csv)
+        t.insert(0, "model", name)
+        frames.append(t)
+    res = pd.concat(frames, ignore_index=True)
+    res.to_csv(out_dir / "subgroup_summary.csv", index=False)
+    return res
+
+
+if __name__ == "__main__":
+    import sys, glob
+    subj = sys.argv[1] if len(sys.argv) > 1 else "data/metadata/subjects_clean.csv"
+    oof_dir = sys.argv[2] if len(sys.argv) > 2 else "results/oof"
+    csvs = {Path(p).stem.replace("oof_", ""): p for p in glob.glob(f"{oof_dir}/oof_*.csv")}
+    print(run_subgroup(csvs, subj, "results/tables/subgroup").to_string(index=False))

src/trifuse/data/cohort.py

@@ -0,0 +1,174 @@
+"""Build the analysis cohort from OASIS-1 per-subject metadata + processed volumes.
+
+The central OASIS-1 demographics spreadsheet URL is dead, so we reconstruct the
+full metadata table by parsing each subject's `OAS1_XXXX_MR1.txt` (present in every
+subject folder) and pairing it with the atlas-registered, brain-masked processed
+volume `*_111_t88_masked_gfc.img`.
+
+Cohort protocol (see plan):
+  - one row per subject (no repeat scans, no reliability sessions)
+  - age >= 60 only  -> breaks the "young brain = CN" age shortcut
+  - label from CDR:  0 -> CN,  0.5 -> VMD (very mild dementia),  >=1 -> AD
+  - CDR & MMSE are NEVER model inputs (label leakage); kept only for analysis.
+"""
+from __future__ import annotations
+
+import glob
+import re
+from pathlib import Path
+
+import pandas as pd
+
+# --- paths -------------------------------------------------------------------
+ROOT = Path(__file__).resolve().parents[3]
+RAW = ROOT / "data" / "raw"
+META_DIR = ROOT / "data" / "metadata"
+
+MIN_AGE = 60
+CLASS_NAMES = ["CN", "VMD", "AD"]
+
+# subject dir looks like  discN/OAS1_0043_MR1/
+SUBJECT_RE = re.compile(r"OAS1_\d{4}_MR1")
+
+
+def _parse_txt(txt_path: Path) -> dict:
+    """Parse the OAS1_XXXX_MR1.txt header block into a flat dict.
+
+    Fields are 'KEY:   value'. Empty values (young subjects lack CDR/Educ/SES)
+    become None. We only read the top demographic block; per-scan blocks below
+    repeat 'TYPE:'/'TR:' etc. and are ignored (we stop at the first scan block).
+    """
+    fields: dict[str, str] = {}
+    for raw_line in txt_path.read_text(errors="ignore").splitlines():
+        if raw_line.strip().startswith("mpr-") or raw_line.strip().startswith("SCAN NUMBER"):
+            break  # reached per-scan section; demographics are all above
+        if ":" not in raw_line:
+            continue
+        key, _, val = raw_line.partition(":")
+        key = key.strip().upper()
+        val = val.strip()
+        if key in {"SESSION ID", "AGE", "M/F", "HAND", "EDUC", "SES",
+                   "CDR", "MMSE", "ETIV", "ASF", "NWBV"}:
+            fields[key] = val if val != "" else None
+    return fields
+
+
+def _to_float(v):
+    if v is None or v == "":
+        return None
+    try:
+        return float(v)
+    except ValueError:
+        return None
+
+
+def _cdr_to_class(cdr: float | None) -> int | None:
+    if cdr is None:
+        return None
+    if cdr == 0.0:
+        return 0  # CN
+    if cdr == 0.5:
+        return 1  # VMD / very mild dementia (NOT clinical MCI)
+    if cdr >= 1.0:
+        return 2  # AD (mild/moderate dementia)
+    return None
+
+
+def _find_masked_volume(subject_dir: Path) -> Path | None:
+    hits = glob.glob(str(subject_dir / "PROCESSED" / "MPRAGE" / "T88_111"
+                         / "*_111_t88_masked_gfc.img"))
+    return Path(hits[0]) if hits else None
+
+
+def scan_subjects(raw_dir: Path = RAW) -> pd.DataFrame:
+    """Walk extracted discs, parse every subject's txt + locate its masked volume.
+
+    Returns the FULL table (all ages, all CDR states) before cohort filtering,
+    so the caller can report how many subjects each filter removes.
+    """
+    rows = []
+    seen: set[str] = set()
+    for txt in sorted(raw_dir.glob("disc*/OAS1_*_MR1/OAS1_*_MR1.txt")):
+        sid_session = txt.parent.name  # OAS1_0043_MR1
+        subject_id = sid_session.replace("_MR1", "")  # OAS1_0043
+        if subject_id in seen:
+            continue  # one row per subject; ignore any duplicate session dirs
+        seen.add(subject_id)
+
+        f = _parse_txt(txt)
+        vol = _find_masked_volume(txt.parent)
+        cdr = _to_float(f.get("CDR"))
+        rows.append({
+            "subject_id": subject_id,
+            "session_id": sid_session,
+            "age": _to_float(f.get("AGE")),
+            "sex": 1 if (f.get("M/F") or "").lower().startswith("m") else 0,
+            "sex_str": f.get("M/F"),
+            "education": _to_float(f.get("EDUC")),
+            "ses": _to_float(f.get("SES")),
+            "cdr": cdr,
+            "mmse": _to_float(f.get("MMSE")),
+            "etiv": _to_float(f.get("ETIV")),
+            "nwbv": _to_float(f.get("NWBV")),
+            "asf": _to_float(f.get("ASF")),
+            "class_id": _cdr_to_class(cdr),
+            "volume_path": str(vol) if vol else None,
+        })
+    return pd.DataFrame(rows)
+
+
+def build_cohort(raw_dir: Path = RAW, min_age: int = MIN_AGE) -> tuple[pd.DataFrame, dict]:
+    """Apply the cohort protocol and return (clean_df, provenance_stats)."""
+    full = scan_subjects(raw_dir)
+    stats = {"n_subjects_total": len(full)}
+
+    # must have a CDR-derived label (drops young no-assessment subjects)
+    has_label = full[full["class_id"].notna()].copy()
+    stats["n_with_cdr_label"] = len(has_label)
+
+    # must have a readable masked volume
+    has_vol = has_label[has_label["volume_path"].notna()].copy()
+    stats["n_with_volume"] = len(has_vol)
+
+    # age >= min_age (break the age shortcut)
+    cohort = has_vol[has_vol["age"] >= min_age].copy()
+    stats["n_age_ge_%d" % min_age] = len(cohort)
+
+    cohort["class_id"] = cohort["class_id"].astype(int)
+    cohort = cohort.sort_values("subject_id").reset_index(drop=True)
+
+    stats["class_counts"] = {
+        CLASS_NAMES[i]: int((cohort["class_id"] == i).sum()) for i in range(3)
+    }
+    stats["age_bands"] = {
+        "60-69": int(((cohort.age >= 60) & (cohort.age < 70)).sum()),
+        "70-79": int(((cohort.age >= 70) & (cohort.age < 80)).sum()),
+        "80+": int((cohort.age >= 80).sum()),
+    }
+    stats["sex_counts"] = {
+        "M": int((cohort.sex == 1).sum()), "F": int((cohort.sex == 0).sum()),
+    }
+    stats["missing"] = {
+        c: int(cohort[c].isna().sum()) for c in ["education", "ses", "etiv", "nwbv", "asf", "mmse"]
+    }
+    return cohort, stats
+
+
+def main():
+    META_DIR.mkdir(parents=True, exist_ok=True)
+    cohort, stats = build_cohort()
+
+    # the model-input columns exclude cdr & mmse (leakage); keep them in the CSV
+    # for analysis but the datasets module must not read them as features.
+    out_cols = ["subject_id", "session_id", "age", "sex", "education", "ses",
+                "etiv", "nwbv", "asf", "cdr", "mmse", "class_id", "volume_path"]
+    cohort[out_cols].to_csv(META_DIR / "subjects_clean.csv", index=False)
+
+    import json
+    (META_DIR / "dataset_statistics.json").write_text(json.dumps(stats, indent=2))
+    print(json.dumps(stats, indent=2))
+    print(f"\nwrote {META_DIR/'subjects_clean.csv'}  ({len(cohort)} subjects)")
+
+
+if __name__ == "__main__":
+    main()

src/trifuse/data/datasets.py

@@ -0,0 +1,168 @@
+"""PyTorch datasets for the three modalities.
+
+All datasets return a uniform batch dict so the trainer is modality-agnostic:
+  {"slices": (T,3,H,W) | "vol": (1,D,H,W), "tab": (F,), "y": int, "subject_id": str}
+
+Tabular features are standardized with statistics FIT ON THE TRAINING FOLD ONLY
+(passed in as `tab_stats`) — never on the full dataset — to prevent leakage.
+Missing tabular values are median/mode-imputed from training-fold stats too.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+
+ROOT = Path(__file__).resolve().parents[3]
+PROC2D = ROOT / "data" / "processed_2d"
+PROC3D = ROOT / "data" / "processed_3d"
+
+# imagenet stats for pretrained backbones (applied after per-volume z-score,
+# so slices are re-scaled into the pretrained input regime)
+IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+IMAGENET_STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+
+
+def fit_tab_stats(df: pd.DataFrame, features) -> dict:
+    """Compute train-fold imputation + standardization stats for tab features."""
+    stats = {}
+    for f in features:
+        col = df[f].astype(float)
+        med = float(col.median())
+        vals = col.fillna(med)
+        mu, sd = float(vals.mean()), float(vals.std())
+        stats[f] = {"median": med, "mean": mu, "std": sd if sd > 1e-6 else 1.0}
+    return stats
+
+
+def _encode_tab(row, features, stats) -> np.ndarray:
+    out = np.zeros(len(features), dtype=np.float32)
+    for i, f in enumerate(features):
+        v = row[f]
+        s = stats[f]
+        if pd.isna(v):
+            v = s["median"]
+        out[i] = (float(v) - s["mean"]) / s["std"]
+    return out
+
+
+class SliceDataset(Dataset):
+    """2D / 2.5D tri-planar slices. planes/n_slices select which of the 27 to load.
+
+    modality:
+      slice2d  -> single center axial slice returned as (1,3,H,W)
+      slice25d -> the requested planes x n_slices as (T,3,H,W)
+    """
+
+    def __init__(self, df, features, tab_stats, planes=("axial",), n_slices=9,
+                 modality="slice25d", augment=False):
+        self.df = df.reset_index(drop=True)
+        self.features = features
+        self.stats = tab_stats
+        self.planes = planes
+        self.n_slices = n_slices
+        self.modality = modality
+        self.augment = augment
+
+    def __len__(self):
+        return len(self.df)
+
+    def _load_plane(self, sid, plane):
+        arr = np.load(PROC2D / sid / plane / "slices.npy").astype(np.float32)  # (9,H,W)
+        # select n_slices centered subset if fewer requested
+        if self.n_slices < arr.shape[0]:
+            start = (arr.shape[0] - self.n_slices) // 2
+            arr = arr[start:start + self.n_slices]
+        return arr
+
+    def _to_rgb(self, sl):  # (H,W) -> (3,H,W) imagenet-normalized
+        x = np.stack([sl, sl, sl], axis=0)
+        x = (x - IMAGENET_MEAN[:, None, None]) / IMAGENET_STD[:, None, None]
+        return x.astype(np.float32)
+
+    def _augment(self, arr):  # light aug on a (n,H,W) stack
+        if not self.augment:
+            return arr
+        if np.random.rand() < 0.5:
+            arr = arr + np.random.normal(0, 0.02, arr.shape).astype(np.float32)
+        if np.random.rand() < 0.5:
+            arr = arr * np.random.uniform(0.95, 1.05)
+        return arr
+
+    def __getitem__(self, idx):
+        row = self.df.iloc[idx]
+        sid = row["subject_id"]
+        if self.modality == "slice2d":
+            axial = self._load_plane(sid, "axial")
+            center = axial[len(axial) // 2]
+            slices = self._to_rgb(self._augment(center[None]))[0][None]  # (1,3,H,W)
+        else:
+            planes = []
+            for p in self.planes:
+                stack = self._augment(self._load_plane(sid, p))
+                planes.append(np.stack([self._to_rgb(s) for s in stack]))  # (n,3,H,W)
+            slices = np.concatenate(planes, axis=0)  # (T,3,H,W)
+        return {
+            "slices": torch.from_numpy(slices),
+            "tab": torch.from_numpy(_encode_tab(row, self.features, self.stats)),
+            "y": int(row["class_id"]),
+            "subject_id": sid,
+        }
+
+
+class VolumeDataset(Dataset):
+    """Whole-brain 3D volumes for CNN3D / transformer / hybrid models."""
+
+    def __init__(self, df, features, tab_stats, target="cnn3d", augment=False):
+        self.df = df.reset_index(drop=True)
+        self.features = features
+        self.stats = tab_stats
+        self.target = target  # cnn3d (128^3) or tf3d (96x112x112)
+        self.augment = augment
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, idx):
+        row = self.df.iloc[idx]
+        sid = row["subject_id"]
+        vol = np.load(PROC3D / self.target / f"{sid}.npy").astype(np.float32)
+        if self.augment and np.random.rand() < 0.5:
+            vol = vol + np.random.normal(0, 0.02, vol.shape).astype(np.float32)
+        return {
+            "vol": torch.from_numpy(vol[None]),  # (1,D,H,W)
+            "tab": torch.from_numpy(_encode_tab(row, self.features, self.stats)),
+            "y": int(row["class_id"]),
+            "subject_id": sid,
+        }
+
+
+class TabularDataset(Dataset):
+    def __init__(self, df, features, tab_stats):
+        self.df = df.reset_index(drop=True)
+        self.features = features
+        self.stats = tab_stats
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, idx):
+        row = self.df.iloc[idx]
+        return {
+            "tab": torch.from_numpy(_encode_tab(row, self.features, self.stats)),
+            "y": int(row["class_id"]),
+            "subject_id": row["subject_id"],
+        }
+
+
+def collate(items):
+    """Uniform collate that stacks whichever tensors are present."""
+    out = {"y": torch.tensor([it["y"] for it in items]),
+           "subject_id": [it["subject_id"] for it in items]}
+    for key in ("slices", "vol", "tab"):
+        if key in items[0]:
+            out[key] = torch.stack([it[key] for it in items])
+    return out

src/trifuse/data/download.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Download + extract OASIS-1 cross-sectional dataset (discs 1-12).
+
+The WashU host throttles per-connection (~48 KB/s single) but not in aggregate:
+16 segmented connections reach ~1.9 MB/s. We use aria2c for segmented download
++ built-in resume. Idempotent: skips discs already extracted.
+"""
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+RAW = Path(__file__).resolve().parents[3] / "data" / "raw"
+BASE = "https://download.nrg.wustl.edu/data"
+N_DISCS = 12
+MIN_DISC_BYTES = 1_000_000_000
+
+
+def download_all() -> None:
+    """aria2c downloads all discs: -x16 conns/host, -s16 segments, -j3 files at once."""
+    urls = [f"{BASE}/oasis_cross-sectional_disc{i}.tar.gz" for i in range(1, N_DISCS + 1)]
+    (RAW / "urls.txt").write_text("\n".join(urls) + "\n")
+    subprocess.run(
+        ["aria2c", "-x16", "-s16", "-j3", "-c", "-k", "1M",
+         "--retry-wait=5", "--max-tries=0",           # 0 = infinite retries
+         "--timeout=30", "--connect-timeout=30",
+         "--summary-interval=30", "--console-log-level=warn",
+         "-d", str(RAW), "-i", str(RAW / "urls.txt")],
+        check=True,
+    )
+
+
+def extract_all() -> None:
+    for i in range(1, N_DISCS + 1):
+        tar_path = RAW / f"oasis_cross-sectional_disc{i}.tar.gz"
+        marker = tar_path.with_suffix(".extracted")
+        if marker.exists():
+            print(f"[skip] disc{i} already extracted", flush=True)
+            continue
+        if not (tar_path.exists() and tar_path.stat().st_size >= MIN_DISC_BYTES):
+            sys.exit(f"disc{i} missing/incomplete: {tar_path}")
+        print(f"[tar ] disc{i}", flush=True)
+        with tarfile.open(tar_path, "r:gz") as t:
+            t.extractall(RAW, filter="data")
+        marker.touch()
+
+
+def main() -> None:
+    RAW.mkdir(parents=True, exist_ok=True)
+    download_all()
+    extract_all()
+    print("[done] all discs downloaded + extracted", flush=True)
+
+
+if __name__ == "__main__":
+    main()

src/trifuse/data/preprocess_2d.py

@@ -0,0 +1,90 @@
+"""2.5D tri-planar slice extraction from processed 3D volumes.
+
+From each normalized volume we take 3 planes (axial, coronal, sagittal) x 9 slices
+at depth fractions 30..70%, giving 27 slices per subject. Each slice is resized to
+224x224 and saved as float16 .npy. The channel dimension (3, for pretrained CNN
+compatibility) is added at load time, not stored, to save disk.
+
+Depth fractions are computed on the *cropped-normalized* volume that preprocess_3d
+produced (background already trimmed), so 50% lands near brain center.
+"""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+from scipy.ndimage import zoom
+
+ROOT = Path(__file__).resolve().parents[3]
+PLANES = ("axial", "coronal", "sagittal")
+DEPTH_FRACTIONS = (0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70)
+SLICE_SIZE = 224
+
+# volume axes after as_closest_canonical (RAS): 0=L-R (sagittal), 1=P-A (coronal),
+# 2=I-S (axial). A slice through an axis shows the *other* two dims.
+PLANE_AXIS = {"sagittal": 0, "coronal": 1, "axial": 2}
+
+
+def _resize2d(sl: np.ndarray, size: int = SLICE_SIZE) -> np.ndarray:
+    factors = [size / sl.shape[0], size / sl.shape[1]]
+    out = zoom(sl, factors, order=1)
+    out = out[:size, :size]
+    pad = [(0, size - out.shape[0]), (0, size - out.shape[1])]
+    if pad[0][1] or pad[1][1]:
+        out = np.pad(out, pad)
+    return out.astype(np.float16)
+
+
+def extract_slices(vol: np.ndarray) -> dict[str, np.ndarray]:
+    """Return {plane: (9, 224, 224) float16} for one volume."""
+    out = {}
+    for plane, axis in PLANE_AXIS.items():
+        n = vol.shape[axis]
+        slabs = []
+        for frac in DEPTH_FRACTIONS:
+            idx = int(round(frac * (n - 1)))
+            sl = np.take(vol, idx, axis=axis)
+            slabs.append(_resize2d(sl))
+        out[plane] = np.stack(slabs)  # (9, 224, 224)
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--subjects_csv", default="data/metadata/subjects_clean.csv")
+    ap.add_argument("--vol_dir", default="data/processed_3d/cnn3d",
+                    help="which processed-3d target to slice from (uses 128^3)")
+    ap.add_argument("--out_root", default="data/processed_2d")
+    ap.add_argument("--limit", type=int, default=0)
+    args = ap.parse_args()
+
+    import pandas as pd
+
+    df = pd.read_csv(args.subjects_csv)
+    if args.limit:
+        df = df.head(args.limit)
+    vol_dir = Path(args.vol_dir)
+    out_root = Path(args.out_root)
+
+    n_ok = 0
+    for _, row in df.iterrows():
+        sid = row["subject_id"]
+        vpath = vol_dir / f"{sid}.npy"
+        if not vpath.exists():
+            print(f"MISS volume for {sid}")
+            continue
+        vol = np.load(vpath)
+        slices = extract_slices(vol)
+        for plane, arr in slices.items():
+            d = out_root / sid / plane
+            d.mkdir(parents=True, exist_ok=True)
+            np.save(d / "slices.npy", arr)
+        n_ok += 1
+        if n_ok % 25 == 0:
+            print(f"  sliced {n_ok}/{len(df)}")
+    print(f"done: {n_ok}/{len(df)} subjects -> {out_root}")
+
+
+if __name__ == "__main__":
+    main()

src/trifuse/data/preprocess_3d.py

@@ -0,0 +1,113 @@
+"""3D preprocessing: OASIS-1 Analyze volume -> normalized .npy.
+
+Pipeline per subject (one volume, the atlas-registered brain-masked gain-field-
+corrected average): read Analyze (.hdr/.img) -> canonical orientation -> nonzero
+bounding-box crop -> percentile clip (0.5-99.5 on brain voxels) -> z-score on
+brain -> resize to target. Two targets are written:
+  - 128^3          for 3D CNN (resnet3d)
+  - 96x112x112     for 3D transformer/hybrid (swin3d, hcct, vswin_lite)
+
+Saved as float32 .npy under processed_3d/<target>/<subject_id>.npy.
+"""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+from scipy.ndimage import zoom
+
+TARGETS = {
+    "cnn3d": (128, 128, 128),
+    "tf3d": (96, 112, 112),
+}
+
+
+def load_analyze(hdr_path: Path) -> np.ndarray:
+    """Load an Analyze/NIfTI volume as float32, reoriented to canonical (RAS)."""
+    img = nib.load(str(hdr_path))
+    img = nib.as_closest_canonical(img)  # consistent orientation across subjects
+    arr = np.asanyarray(img.dataobj).astype(np.float32)
+    arr = np.squeeze(arr)  # OASIS T88 volumes carry a trailing singleton axis
+    return arr
+
+
+def nonzero_bbox_crop(vol: np.ndarray) -> np.ndarray:
+    mask = vol > 0
+    if not mask.any():
+        return vol
+    coords = np.array(np.nonzero(mask))
+    lo = coords.min(axis=1)
+    hi = coords.max(axis=1) + 1
+    return vol[lo[0]:hi[0], lo[1]:hi[1], lo[2]:hi[2]]
+
+
+def clip_and_zscore(vol: np.ndarray) -> np.ndarray:
+    brain = vol[vol > 0]
+    if brain.size == 0:
+        return vol
+    lo, hi = np.percentile(brain, [0.5, 99.5])
+    vol = np.clip(vol, lo, hi)
+    brain = vol[vol > 0]
+    mu, sd = brain.mean(), brain.std()
+    if sd < 1e-6:
+        sd = 1.0
+    out = (vol - mu) / sd
+    out[vol <= 0] = 0.0  # keep background at 0 after normalization
+    return out.astype(np.float32)
+
+
+def resize_to(vol: np.ndarray, shape: tuple[int, int, int]) -> np.ndarray:
+    factors = [s / v for s, v in zip(shape, vol.shape)]
+    out = zoom(vol, factors, order=1)  # trilinear
+    # guard against off-by-one from rounding
+    out = out[: shape[0], : shape[1], : shape[2]]
+    pad = [(0, s - o) for s, o in zip(shape, out.shape)]
+    if any(p[1] > 0 for p in pad):
+        out = np.pad(out, pad)
+    return out.astype(np.float32)
+
+
+def preprocess_one(hdr_path: Path) -> dict[str, np.ndarray]:
+    vol = load_analyze(hdr_path)
+    vol = nonzero_bbox_crop(vol)
+    vol = clip_and_zscore(vol)
+    return {name: resize_to(vol, shape) for name, shape in TARGETS.items()}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--subjects_csv", default="data/metadata/subjects_clean.csv")
+    ap.add_argument("--out_root", default="data/processed_3d")
+    ap.add_argument("--limit", type=int, default=0, help="process only first N (debug)")
+    args = ap.parse_args()
+
+    import pandas as pd
+
+    df = pd.read_csv(args.subjects_csv)
+    if args.limit:
+        df = df.head(args.limit)
+    out_root = Path(args.out_root)
+    for name in TARGETS:
+        (out_root / name).mkdir(parents=True, exist_ok=True)
+
+    n_ok = 0
+    for _, row in df.iterrows():
+        sid = row["subject_id"]
+        hdr = Path(row["volume_path"])
+        try:
+            outs = preprocess_one(hdr)
+        except Exception as e:  # noqa: BLE001 - report and continue
+            print(f"FAIL {sid}: {e}")
+            continue
+        for name, arr in outs.items():
+            np.save(out_root / name / f"{sid}.npy", arr)
+        n_ok += 1
+        if n_ok % 25 == 0:
+            print(f"  processed {n_ok}/{len(df)}")
+    print(f"done: {n_ok}/{len(df)} volumes -> {out_root}")
+
+
+if __name__ == "__main__":
+    main()

src/trifuse/data/splits.py

@@ -0,0 +1,90 @@
+"""Subject-level repeated stratified cross-validation splits.
+
+Leakage prevention is the whole point: splitting happens at the subject level (one
+volume per subject, so no subject appears in both train and test). Stratification
+uses a composite key of class x age-band x sex so folds stay balanced on all three.
+
+For each of 3 seeds we build a 5-fold split (15 evaluations total). Within each
+outer fold, the training portion is further split 80/20 into train/val for
+early stopping. All fitting (impute/standardize/class-weights) must happen on the
+train portion only -- handled downstream, not here.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import StratifiedKFold, train_test_split
+
+SEEDS = [7, 13, 21]
+N_FOLDS = 5
+VAL_FRACTION = 0.2
+
+
+def age_band(age: float) -> str:
+    if age < 70:
+        return "60s"
+    if age < 80:
+        return "70s"
+    return "80+"
+
+
+def _strata_key(df: pd.DataFrame) -> pd.Series:
+    bands = df["age"].apply(age_band)
+    return df["class_id"].astype(str) + "_" + bands + "_" + df["sex"].astype(str)
+
+
+def _merge_rare(strata: pd.Series, min_count: int = 2) -> pd.Series:
+    """StratifiedKFold needs every stratum to have >= n_splits members ideally;
+    collapse ultra-rare composite strata down to the class label alone."""
+    counts = strata.value_counts()
+    rare = set(counts[counts < min_count].index)
+    return strata.map(lambda s: s.split("_")[0] if s in rare else s)
+
+
+def make_folds(df: pd.DataFrame) -> pd.DataFrame:
+    """Return a long-form dataframe: one row per (subject, seed) giving fold id
+    and the train/val/test role for the fold where the subject is in test.
+
+    Output columns: subject_id, seed, fold (int, the test fold this subject
+    belongs to). Downstream, evaluation `(seed, fold)` uses fold==test, and the
+    remaining subjects are the train pool (val carved out per model run).
+    """
+    records = []
+    strata_full = _merge_rare(_strata_key(df))
+    for seed in SEEDS:
+        skf = StratifiedKFold(n_splits=N_FOLDS, shuffle=True, random_state=seed)
+        fold_of = np.empty(len(df), dtype=int)
+        for fold_idx, (_, test_idx) in enumerate(skf.split(df, strata_full)):
+            fold_of[test_idx] = fold_idx
+        for sid, fold in zip(df["subject_id"].to_numpy(), fold_of):
+            records.append({"subject_id": sid, "seed": seed, "fold": int(fold)})
+    return pd.DataFrame.from_records(records)
+
+
+def split_for(folds: pd.DataFrame, df: pd.DataFrame, seed: int, fold: int):
+    """Return (train_ids, val_ids, test_ids) for one (seed, fold) evaluation.
+
+    Test = subjects whose assigned fold == `fold` for this seed. Remaining are
+    split into train/val (stratified on class) using the same seed for
+    reproducibility.
+    """
+    fs = folds[folds["seed"] == seed]
+    test_ids = fs.loc[fs["fold"] == fold, "subject_id"].tolist()
+    trainval_ids = fs.loc[fs["fold"] != fold, "subject_id"].tolist()
+
+    sub = df[df["subject_id"].isin(trainval_ids)]
+    strat = sub["class_id"]
+    train_ids, val_ids = train_test_split(
+        sub["subject_id"].tolist(),
+        test_size=VAL_FRACTION,
+        random_state=seed,
+        stratify=strat,
+    )
+    return train_ids, val_ids, test_ids
+
+
+def assert_no_leakage(train_ids, val_ids, test_ids) -> None:
+    s_tr, s_va, s_te = set(train_ids), set(val_ids), set(test_ids)
+    assert not (s_tr & s_te), "train/test subject overlap"
+    assert not (s_tr & s_va), "train/val subject overlap"
+    assert not (s_va & s_te), "val/test subject overlap"

src/trifuse/eval/metrics.py

@@ -0,0 +1,71 @@
+"""Evaluation metrics for 3-class Alzheimer staging.
+
+Primary metric is Macro-F1 (class imbalance: AD is the minority). All metrics
+computed from (y_true, y_pred) label arrays plus optional probabilities for AUC.
+"""
+from __future__ import annotations
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    balanced_accuracy_score,
+    confusion_matrix,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_auc_score,
+)
+
+CLASS_NAMES = ["CN", "VMD", "AD"]  # 0, 1, 2
+N_CLASSES = 3
+
+
+def compute_metrics(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    y_prob: np.ndarray | None = None,
+) -> dict[str, float]:
+    """Return the full metric dict for one set of predictions.
+
+    y_prob: (N, 3) class probabilities; if given, OvR macro-AUC is added.
+    """
+    y_true = np.asarray(y_true).astype(int)
+    y_pred = np.asarray(y_pred).astype(int)
+    labels = list(range(N_CLASSES))
+
+    out: dict[str, float] = {
+        "accuracy": float(accuracy_score(y_true, y_pred)),
+        "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)),
+        "macro_f1": float(f1_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
+        "macro_precision": float(precision_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
+        "macro_recall": float(recall_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
+    }
+
+    per_f1 = f1_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
+    per_recall = recall_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
+    per_prec = precision_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
+    for i, name in enumerate(CLASS_NAMES):
+        out[f"f1_{name}"] = float(per_f1[i])
+        out[f"recall_{name}"] = float(per_recall[i])
+        out[f"precision_{name}"] = float(per_prec[i])
+
+    if y_prob is not None:
+        y_prob = np.asarray(y_prob, dtype=float)
+        # OvR macro-AUC; guard against a class absent from y_true in this split.
+        present = np.unique(y_true)
+        if len(present) == N_CLASSES:
+            try:
+                out["macro_auc"] = float(
+                    roc_auc_score(y_true, y_prob, multi_class="ovr", average="macro", labels=labels)
+                )
+            except ValueError:
+                out["macro_auc"] = float("nan")
+        else:
+            out["macro_auc"] = float("nan")
+    return out
+
+
+def confusion(y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:
+    return confusion_matrix(np.asarray(y_true).astype(int),
+                            np.asarray(y_pred).astype(int),
+                            labels=list(range(N_CLASSES)))

src/trifuse/eval/runner.py

@@ -0,0 +1,152 @@
+"""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/<name>/: 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

src/trifuse/eval/stats.py

@@ -0,0 +1,71 @@
+"""Statistical analysis of cross-validation results.
+
+Aggregates per-(seed,fold) metrics into mean±std, computes bootstrap 95% CIs from
+pooled out-of-fold (OOF) predictions, and runs a paired test comparing the proposed
+model against the best baseline across the 15 evaluations.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from sklearn.metrics import f1_score
+
+from .metrics import compute_metrics
+
+
+def aggregate_runs(run_metrics: list[dict]) -> dict[str, tuple[float, float]]:
+    """[{metric: value}, ...] over runs -> {metric: (mean, std)}."""
+    keys = run_metrics[0].keys()
+    out = {}
+    for k in keys:
+        vals = np.array([m[k] for m in run_metrics if not np.isnan(m[k])])
+        if len(vals):
+            out[k] = (float(vals.mean()), float(vals.std()))
+    return out
+
+
+def bootstrap_ci(oof: pd.DataFrame, metric: str = "macro_f1",
+                 n_boot: int = 2000, seed: int = 0) -> tuple[float, float, float]:
+    """Bootstrap 95% CI for a metric over pooled OOF predictions.
+
+    oof: columns subject_id, y_true, y_pred (+ prob_0..2). Resamples subjects.
+    Returns (point_estimate, lo, hi).
+    """
+    rng = np.random.default_rng(seed)
+    y_true = oof["y_true"].to_numpy()
+    y_pred = oof["y_pred"].to_numpy()
+    n = len(oof)
+    point = f1_score(y_true, y_pred, labels=[0, 1, 2], average="macro", zero_division=0)
+    stats = np.empty(n_boot)
+    for b in range(n_boot):
+        idx = rng.integers(0, n, n)
+        stats[b] = f1_score(y_true[idx], y_pred[idx], labels=[0, 1, 2],
+                            average="macro", zero_division=0)
+    lo, hi = np.percentile(stats, [2.5, 97.5])
+    return float(point), float(lo), float(hi)
+
+
+def paired_permutation_test(scores_a: list[float], scores_b: list[float],
+                            n_perm: int = 10000, seed: int = 0) -> float:
+    """Two-sided paired permutation test on per-run metric differences.
+
+    scores_a, scores_b: paired per-(seed,fold) metric values (same order).
+    Returns p-value for H0: mean(a-b)=0.
+    """
+    rng = np.random.default_rng(seed)
+    a, b = np.asarray(scores_a), np.asarray(scores_b)
+    diff = a - b
+    obs = abs(diff.mean())
+    count = 0
+    for _ in range(n_perm):
+        signs = rng.choice([-1, 1], size=len(diff))
+        if abs((diff * signs).mean()) >= obs - 1e-12:
+            count += 1
+    return (count + 1) / (n_perm + 1)
+
+
+def oof_metrics(oof: pd.DataFrame) -> dict:
+    """Compute the full metric dict on pooled OOF predictions."""
+    prob_cols = [c for c in oof.columns if c.startswith("prob_")]
+    prob = oof[sorted(prob_cols)].to_numpy() if prob_cols else None
+    return compute_metrics(oof["y_true"].to_numpy(), oof["y_pred"].to_numpy(), prob)

src/trifuse/experiments.py

@@ -0,0 +1,67 @@
+"""Experiment grid: every model config for the main table, ablation, and confound.
+
+Defined as TrainConfig factories (not loose YAML) so the grid is typed and the
+runner can iterate deterministically. Epochs are tuned to the small cohort
+(198 subjects) — early stopping on val Macro-F1 usually halts well before the cap.
+"""
+from __future__ import annotations
+
+from trifuse.training.config import TrainConfig
+
+TRI = ("axial", "coronal", "sagittal")
+
+
+def main_grid() -> list[TrainConfig]:
+    return [
+        # --- tabular ---
+        TrainConfig(name="xgboost", model="xgboost", modality="tabular"),
+        TrainConfig(name="tabular_mlp", model="tabular_mlp", modality="tabular",
+                    epochs=80, batch_size=16, lr=1e-3),
+        # --- CNN ---
+        TrainConfig(name="resnet50", model="resnet50", modality="slice2d",
+                    epochs=60, batch_size=16, lr=3e-4, backbone_lr=3e-5,
+                    freeze_epochs=5),
+        TrainConfig(name="densenet2p5d", model="densenet2p5d", modality="slice25d",
+                    n_slices=9, planes=("axial",), epochs=60, batch_size=8,
+                    lr=3e-4, backbone_lr=3e-5, freeze_epochs=5),
+        TrainConfig(name="resnet3d", model="resnet3d", modality="vol3d",
+                    vol_size=(128, 128, 128), epochs=100, batch_size=8,
+                    lr=1e-4),
+        # --- transformers ---
+        TrainConfig(name="vit_b16", model="vit2d", modality="slice25d",
+                    n_slices=9, planes=("axial",), epochs=60, batch_size=8,
+                    lr=3e-4, backbone_lr=1e-5, freeze_epochs=8, unfreeze_last_n=2),
+        TrainConfig(name="swin3d", model="swin3d", modality="vol3d",
+                    vol_size=(96, 112, 112), epochs=80, batch_size=8,
+                    lr=1e-4),
+        # --- recent hybrids (retrained on our folds) ---
+        TrainConfig(name="hcct", model="hcct", modality="vol3d",
+                    vol_size=(96, 112, 112), epochs=80, batch_size=8,
+                    lr=1e-4),
+        TrainConfig(name="vswin_lite", model="vswin_lite", modality="vol3d",
+                    vol_size=(96, 112, 112), epochs=80, batch_size=8,
+                    lr=1e-4),
+        # --- multimodal baseline ---
+        TrainConfig(name="densenet_latefusion", model="densenet_latefusion",
+                    modality="multimodal", n_slices=9, planes=("axial",),
+                    epochs=60, batch_size=8, lr=3e-4, backbone_lr=3e-5, freeze_epochs=5),
+        # --- proposed ---
+        TrainConfig(name="trifuse_ad", model="trifuse", modality="multimodal",
+                    n_slices=9, planes=TRI, epochs=70, batch_size=6,
+                    lr=3e-4, backbone_lr=3e-5, freeze_epochs=6, grad_accum=2),
+    ]
+
+
+def ablation_grid() -> list[TrainConfig]:
+    """A1-A5 + full, all sharing TriFuse-AD's training recipe."""
+    base = dict(modality="multimodal", n_slices=9, epochs=70, batch_size=6,
+                lr=3e-4, backbone_lr=3e-5, freeze_epochs=6, grad_accum=2)
+    return [
+        TrainConfig(name="abl_A1_axial", model="trifuse", planes=("axial",), **base),
+        TrainConfig(name="abl_A2_meanpool", model="trifuse_meanpool", planes=TRI, **base),
+        TrainConfig(name="abl_A3_nometa", model="trifuse_nometa", planes=TRI, **base),
+        TrainConfig(name="abl_A4_concat", model="trifuse_concat", planes=TRI, **base),
+        TrainConfig(name="abl_A5_weightedce", model="trifuse", planes=TRI,
+                    loss="weighted_ce", **base),
+        TrainConfig(name="abl_full", model="trifuse", planes=TRI, **base),
+    ]

src/trifuse/models/baselines_tab.py

@@ -0,0 +1,43 @@
+"""Tabular baselines on demographic + morphometric features.
+
+Allowed features (NO CDR, NO MMSE — those are label-leaking): age, sex, education,
+ses, etiv, nwbv, asf. XGBoost is used both as a main baseline (B0) and as the
+shortcut/confound probe (age-only, demographic-only, full-structured).
+"""
+from __future__ import annotations
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+FEATURES_FULL = ["age", "sex", "education", "ses", "etiv", "nwbv", "asf"]
+FEATURES_DEMO = ["age", "sex", "education", "ses"]
+FEATURES_AGE = ["age"]
+
+
+def make_xgb(n_classes: int = 3, seed: int = 0):
+    """Return an XGBoost classifier configured for small-n multiclass."""
+    from xgboost import XGBClassifier
+    return XGBClassifier(
+        n_estimators=300, max_depth=3, learning_rate=0.05,
+        subsample=0.8, colsample_bytree=0.8, reg_lambda=1.0,
+        objective="multi:softprob", num_class=n_classes,
+        eval_metric="mlogloss", tree_method="hist",
+        random_state=seed, n_jobs=4,
+    )
+
+
+class TabularMLP(nn.Module):
+    """Neural tabular baseline (B1) and the metadata branch reference."""
+
+    def __init__(self, n_features: int = 7, n_classes: int = 3, hidden: int = 128,
+                 dropout: float = 0.3):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(n_features, 64), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(64, hidden), nn.GELU(), nn.LayerNorm(hidden),
+            nn.Dropout(dropout), nn.Linear(hidden, n_classes),
+        )
+
+    def forward(self, tab: torch.Tensor, *_unused) -> torch.Tensor:
+        return self.net(tab)

src/trifuse/models/cnn2d.py

@@ -0,0 +1,72 @@
+"""2D / 2.5D CNN baselines (timm backbones).
+
+- ResNet50Center: single center axial slice (B, 3, H, W).
+- DenseNet2p5D: 9 axial slices encoded by a shared backbone, mean-pooled (2.5D).
+Both accept the same (B, T, 3, H, W) slice tensor as the rest of the zoo; T is
+sliced/agg internally so the training loop is uniform.
+"""
+from __future__ import annotations
+
+import timm
+import torch
+import torch.nn as nn
+
+
+class ResNet50Center(nn.Module):
+    """Single-slice baseline: uses the center slice of the axial stack."""
+
+    def __init__(self, n_classes: int = 3, pretrained: bool = True,
+                 backbone: str = "resnet50", center_index: int | None = None):
+        super().__init__()
+        self.backbone = timm.create_model(backbone, pretrained=pretrained, num_classes=n_classes, in_chans=3)
+        self.center_index = center_index
+
+    def forward(self, slices: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        # slices: (B, T, 3, H, W); pick center of the (first) plane's stack
+        T = slices.shape[1]
+        idx = self.center_index if self.center_index is not None else T // 2
+        return self.backbone(slices[:, idx])
+
+
+class DenseNet2p5D(nn.Module):
+    """2.5D baseline: shared DenseNet over N slices, mean-pool logits."""
+
+    def __init__(self, n_classes: int = 3, pretrained: bool = True,
+                 backbone: str = "densenet121", n_slices: int = 9):
+        super().__init__()
+        self.encoder = timm.create_model(backbone, pretrained=pretrained, num_classes=0, in_chans=3)
+        self.head = nn.Linear(self.encoder.num_features, n_classes)
+        self.n_slices = n_slices
+
+    def forward(self, slices: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        # use first n_slices tokens (axial plane) -> mean-pool features
+        x = slices[:, : self.n_slices]                      # (B, S, 3, H, W)
+        B, S, C, H, W = x.shape
+        feats = self.encoder(x.reshape(B * S, C, H, W)).reshape(B, S, -1)
+        return self.head(feats.mean(dim=1))
+
+
+class DenseNetLateFusion(nn.Module):
+    """Multimodal baseline B9: DenseNet 2.5D image embedding + metadata MLP, concat."""
+
+    def __init__(self, n_classes: int = 3, n_tab_features: int = 7,
+                 pretrained: bool = True, backbone: str = "densenet121", n_slices: int = 9,
+                 dropout: float = 0.3):
+        super().__init__()
+        self.encoder = timm.create_model(backbone, pretrained=pretrained, num_classes=0, in_chans=3)
+        img_dim = self.encoder.num_features
+        self.n_slices = n_slices
+        self.tab = nn.Sequential(
+            nn.Linear(n_tab_features, 64), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(64, 128), nn.LayerNorm(128),
+        )
+        self.head = nn.Sequential(
+            nn.Linear(img_dim + 128, 256), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(256, n_classes),
+        )
+
+    def forward(self, slices: torch.Tensor, tab: torch.Tensor) -> torch.Tensor:
+        x = slices[:, : self.n_slices]
+        B, S, C, H, W = x.shape
+        img = self.encoder(x.reshape(B * S, C, H, W)).reshape(B, S, -1).mean(dim=1)
+        return self.head(torch.cat([img, self.tab(tab)], dim=1))

src/trifuse/models/cnn3d.py

@@ -0,0 +1,21 @@
+"""3D CNN baseline: whole-brain volume classification via MONAI ResNet.
+
+Input volumes are (B, 1, D, H, W). MONAI's resnet18 with spatial_dims=3 is a clean,
+reproducible baseline for the value-of-volume question.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+from monai.networks.nets import resnet18
+
+
+class ResNet3D(nn.Module):
+    def __init__(self, n_classes: int = 3, in_channels: int = 1):
+        super().__init__()
+        self.net = resnet18(
+            spatial_dims=3, n_input_channels=in_channels, num_classes=n_classes,
+        )
+
+    def forward(self, vol: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        return self.net(vol)

src/trifuse/models/fusion.py

@@ -0,0 +1,50 @@
+"""Clinical-guided gated fusion of MRI and tabular embeddings.
+
+Instead of plain concatenation [z_mri; z_tab], learn a gate g = sigma(Wg[z_mri;z_tab])
+that scales the tabular contribution before residual-adding it into the MRI stream:
+
+    z = LayerNorm(z_mri + g * (Wt z_tab))
+
+Rationale: when demographics (esp. age) are informative the gate opens; when they are
+unreliable or missing the MRI branch stays dominant, preventing age from swamping the
+imaging signal. This is the mechanism ablation A4 (concat) tests against.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+class GatedFusion(nn.Module):
+    def __init__(self, mri_dim: int, tab_dim: int, dropout: float = 0.1):
+        super().__init__()
+        self.tab_proj = nn.Linear(tab_dim, mri_dim)
+        self.gate = nn.Sequential(
+            nn.Linear(mri_dim + tab_dim, mri_dim),
+            nn.Sigmoid(),
+        )
+        self.norm = nn.LayerNorm(mri_dim)
+        self.drop = nn.Dropout(dropout)
+        self.out_dim = mri_dim
+
+    def forward(self, z_mri: torch.Tensor, z_tab: torch.Tensor) -> torch.Tensor:
+        g = self.gate(torch.cat([z_mri, z_tab], dim=-1))   # (B, mri_dim)
+        t = self.tab_proj(z_tab)                            # (B, mri_dim)
+        z = self.norm(z_mri + g * t)
+        return self.drop(z)
+
+
+class ConcatFusion(nn.Module):
+    """Ablation A4: plain concatenation baseline (no gate)."""
+
+    def __init__(self, mri_dim: int, tab_dim: int, dropout: float = 0.1):
+        super().__init__()
+        self.proj = nn.Sequential(
+            nn.Linear(mri_dim + tab_dim, mri_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+        )
+        self.out_dim = mri_dim
+
+    def forward(self, z_mri: torch.Tensor, z_tab: torch.Tensor) -> torch.Tensor:
+        return self.proj(torch.cat([z_mri, z_tab], dim=-1))

src/trifuse/models/hybrids.py

@@ -0,0 +1,129 @@
+"""Recent CNN-Transformer hybrid baselines, re-implemented compact for OASIS-1.
+
+Both are TRAINED ON OUR FOLDS — no published cross-dataset numbers are copied.
+
+- HCCTCompact: 3D convolutional stem -> compact conv blocks -> 3D patch tokens ->
+  Transformer encoder -> classification head. After Krishnan et al. 3D HCCT (2024).
+- VSwinFormerLite: residual depthwise 3D CNN stem + 3D CBAM -> Swin-Tiny 3D stages ->
+  GAP -> head. After the 3D-CNN + Video Swin model (Sci Reports 2025), lite variant.
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+# --------------------------- 3D HCCT (compact) ---------------------------
+class ConvBlock3D(nn.Module):
+    def __init__(self, cin, cout, stride=1):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv3d(cin, cout, 3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm3d(cout), nn.GELU(),
+            nn.Conv3d(cout, cout, 3, padding=1, bias=False),
+            nn.BatchNorm3d(cout), nn.GELU(),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class HCCTCompact(nn.Module):
+    def __init__(self, n_classes: int = 3, in_channels: int = 1, embed_dim: int = 256,
+                 n_layers: int = 3, n_heads: int = 8, dropout: float = 0.1):
+        super().__init__()
+        self.stem = nn.Sequential(
+            nn.Conv3d(in_channels, 32, 3, stride=2, padding=1, bias=False),
+            nn.BatchNorm3d(32), nn.GELU(),
+        )
+        self.blocks = nn.Sequential(
+            ConvBlock3D(32, 64, stride=2),
+            ConvBlock3D(64, 128, stride=2),
+            ConvBlock3D(128, embed_dim, stride=2),
+        )
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        nn.init.trunc_normal_(self.cls_token, std=0.02)
+        self.pos_drop = nn.Dropout(dropout)
+        layer = nn.TransformerEncoderLayer(
+            d_model=embed_dim, nhead=n_heads, dim_feedforward=embed_dim * 4,
+            dropout=dropout, batch_first=True, activation="gelu", norm_first=True,
+        )
+        self.transformer = nn.TransformerEncoder(layer, num_layers=n_layers)
+        self.norm = nn.LayerNorm(embed_dim)
+        self.head = nn.Linear(embed_dim, n_classes)
+
+    def forward(self, vol: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        x = self.blocks(self.stem(vol))              # (B, C, d, h, w)
+        B, C = x.shape[:2]
+        tokens = x.flatten(2).transpose(1, 2)        # (B, N, C)
+        cls = self.cls_token.expand(B, -1, -1)
+        seq = self.pos_drop(torch.cat([cls, tokens], dim=1))
+        seq = self.transformer(seq)
+        return self.head(self.norm(seq[:, 0]))
+
+
+# --------------------- 3D-CNN-VSwinFormer (lite) ---------------------
+class CBAM3D(nn.Module):
+    """3D convolutional block attention (channel + spatial)."""
+
+    def __init__(self, channels, reduction=8):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(channels, channels // reduction), nn.ReLU(inplace=True),
+            nn.Linear(channels // reduction, channels),
+        )
+        self.spatial = nn.Conv3d(2, 1, 7, padding=3, bias=False)
+
+    def forward(self, x):
+        b, c = x.shape[:2]
+        avg = self.mlp(x.mean(dim=(2, 3, 4)))
+        mx = self.mlp(x.amax(dim=(2, 3, 4)))
+        ca = torch.sigmoid(avg + mx).view(b, c, 1, 1, 1)
+        x = x * ca
+        sa = torch.cat([x.mean(1, keepdim=True), x.amax(1, keepdim=True)], dim=1)
+        x = x * torch.sigmoid(self.spatial(sa))
+        return x
+
+
+class ResDepthwise3D(nn.Module):
+    def __init__(self, cin, cout, stride=1):
+        super().__init__()
+        self.dw = nn.Conv3d(cin, cin, 3, stride=stride, padding=1, groups=cin, bias=False)
+        self.pw = nn.Conv3d(cin, cout, 1, bias=False)
+        self.bn = nn.BatchNorm3d(cout)
+        self.act = nn.GELU()
+        self.proj = (nn.Conv3d(cin, cout, 1, stride=stride, bias=False)
+                     if (cin != cout or stride != 1) else nn.Identity())
+
+    def forward(self, x):
+        out = self.act(self.bn(self.pw(self.dw(x))))
+        return out + self.proj(x)
+
+
+class VSwinFormerLite(nn.Module):
+    """Residual depthwise CNN stem + CBAM, then a MONAI 3D Swin encoder, GAP + head."""
+
+    def __init__(self, n_classes: int = 3, in_channels: int = 1, img_size=(96, 112, 112)):
+        super().__init__()
+        self.stem = nn.Sequential(
+            nn.Conv3d(in_channels, 32, 3, stride=2, padding=1, bias=False),
+            nn.BatchNorm3d(32), nn.GELU(),
+            ResDepthwise3D(32, 48),
+            ResDepthwise3D(48, 48),
+            CBAM3D(48),
+        )
+        from monai.networks.nets.swin_unetr import SwinTransformer
+        from monai.utils import ensure_tuple_rep
+        self.swin = SwinTransformer(
+            in_chans=48, embed_dim=48,
+            window_size=ensure_tuple_rep(7, 3), patch_size=ensure_tuple_rep(2, 3),
+            depths=(2, 2, 2, 2), num_heads=(3, 6, 12, 24), spatial_dims=3,
+        )
+        self.norm = nn.LayerNorm(48 * 16)
+        self.head = nn.Linear(48 * 16, n_classes)
+
+    def forward(self, vol: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        x = self.stem(vol)
+        feats = self.swin(x)[-1]
+        pooled = feats.flatten(2).mean(-1)
+        return self.head(self.norm(pooled))

src/trifuse/models/registry.py

@@ -0,0 +1,50 @@
+"""Model registry: maps a config `model` key to a constructed nn.Module.
+
+Every model's forward signature is (primary_input, tab=None) so the trainer can
+call them uniformly. `modality` (from config) decides which input the loader feeds
+as `primary_input`: slice tensor (B,T,3,H,W), volume (B,1,D,H,W), or tabular (B,F).
+"""
+from __future__ import annotations
+
+from .cnn2d import ResNet50Center, DenseNet2p5D, DenseNetLateFusion
+from .cnn3d import ResNet3D
+from .transformers import ViT2D, SwinT3D
+from .hybrids import HCCTCompact, VSwinFormerLite
+from .trifuse import TriFuseAD
+from .baselines_tab import TabularMLP
+
+
+def build_model(cfg, n_tab_features: int = 7, pretrained: bool = True):
+    m = cfg.model
+    n = 3
+    if m == "tabular_mlp":
+        return TabularMLP(n_features=n_tab_features, n_classes=n, dropout=cfg.dropout)
+    if m == "resnet50":
+        return ResNet50Center(n_classes=n, pretrained=pretrained)
+    if m == "densenet2p5d":
+        return DenseNet2p5D(n_classes=n, pretrained=pretrained, n_slices=cfg.n_slices)
+    if m == "resnet3d":
+        return ResNet3D(n_classes=n)
+    if m == "vit2d":
+        return ViT2D(n_classes=n, pretrained=pretrained)
+    if m == "swin3d":
+        return SwinT3D(n_classes=n, img_size=cfg.vol_size)
+    if m == "hcct":
+        return HCCTCompact(n_classes=n)
+    if m == "vswin_lite":
+        return VSwinFormerLite(n_classes=n, img_size=cfg.vol_size)
+    if m == "densenet_latefusion":
+        return DenseNetLateFusion(n_classes=n, n_tab_features=n_tab_features,
+                                  pretrained=pretrained, n_slices=cfg.n_slices, dropout=cfg.dropout)
+    if m.startswith("trifuse"):
+        # ablation flags encoded in the model key: trifuse, trifuse_axial, trifuse_meanpool,
+        # trifuse_nometa, trifuse_concat
+        return TriFuseAD(
+            n_classes=n, n_tab_features=n_tab_features,
+            planes=tuple(cfg.planes), n_slices=cfg.n_slices, dropout=cfg.dropout,
+            use_transformer=("meanpool" not in m),
+            use_metadata=("nometa" not in m),
+            fusion=("concat" if "concat" in m else "gated"),
+            pretrained=pretrained,
+        )
+    raise ValueError(f"unknown model key: {m}")

src/trifuse/models/transformers.py

@@ -0,0 +1,76 @@
+"""Transformer baselines.
+
+- ViT2D: ViT-B/16 (timm, pretrained) over 2.5D multi-slice input. Slices are
+  encoded independently by the shared ViT and mean-pooled, then classified.
+  Supports 2-stage fine-tuning via freeze_backbone().
+- SwinT3D: MONAI SwinUNETR encoder (Swin-Tiny-scale) over a 3D crop, GAP + head.
+"""
+from __future__ import annotations
+
+import timm
+import torch
+import torch.nn as nn
+
+
+class ViT2D(nn.Module):
+    """ViT-B/16 over N 2D slices, mean-pooled embeddings -> classifier.
+
+    Input: (B, N, 3, 224, 224) or (B, 3, 224, 224). Shared backbone across slices.
+    """
+
+    def __init__(self, n_classes: int = 3, pretrained: bool = True):
+        super().__init__()
+        self.backbone = timm.create_model(
+            "vit_base_patch16_224", pretrained=pretrained, num_classes=0,
+        )
+        self.embed_dim = self.backbone.num_features  # 768
+        self.head = nn.Linear(self.embed_dim, n_classes)
+
+    def freeze_backbone(self, freeze: bool = True):
+        for p in self.backbone.parameters():
+            p.requires_grad = not freeze
+
+    def unfreeze_last_blocks(self, n_blocks: int = 2):
+        self.freeze_backbone(True)
+        for blk in self.backbone.blocks[-n_blocks:]:
+            for p in blk.parameters():
+                p.requires_grad = True
+        for p in self.backbone.norm.parameters():
+            p.requires_grad = True
+
+    def forward(self, x: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        if x.dim() == 4:
+            x = x.unsqueeze(1)  # (B,1,3,224,224)
+        b, n = x.shape[:2]
+        x = x.flatten(0, 1)                     # (B*N,3,224,224)
+        feats = self.backbone(x)                # (B*N,768)
+        feats = feats.view(b, n, -1).mean(1)    # mean-pool slices
+        return self.head(feats)
+
+
+class SwinT3D(nn.Module):
+    """3D Swin transformer encoder (Swin-Tiny scale) via MONAI, GAP + linear head."""
+
+    def __init__(self, n_classes: int = 3, in_channels: int = 1, img_size=(96, 112, 112)):
+        super().__init__()
+        from monai.networks.nets.swin_unetr import SwinTransformer
+        from monai.utils import ensure_tuple_rep
+
+        patch = ensure_tuple_rep(2, 3)
+        window = ensure_tuple_rep(7, 3)
+        self.swin = SwinTransformer(
+            in_chans=in_channels,
+            embed_dim=48,
+            window_size=window,
+            patch_size=patch,
+            depths=(2, 2, 2, 2),
+            num_heads=(3, 6, 12, 24),
+            spatial_dims=3,
+        )
+        self.norm = nn.LayerNorm(48 * 16)
+        self.head = nn.Linear(48 * 16, n_classes)
+
+    def forward(self, vol: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        feats = self.swin(vol)[-1]              # deepest stage (B, 8C, d, h, w)
+        pooled = feats.flatten(2).mean(-1)      # GAP -> (B, 8C)
+        return self.head(self.norm(pooled))

src/trifuse/models/trifuse.py

@@ -0,0 +1,128 @@
+"""TriFuse-AD: tri-planar CNN + slice-plane Transformer + gated metadata fusion.
+
+Pipeline:
+  27 slices (3 planes x 9) -> shared 2D CNN encoder (timm ConvNeXt-Tiny) -> 27 tokens
+  + slice pos-emb + plane emb + [CLS] -> 2-layer Transformer encoder -> z_mri (CLS)
+  metadata (7 feats) -> MLP -> z_tab
+  GatedFusion(z_mri, z_tab) -> classifier -> 3 logits
+
+Ablation knobs (set via constructor so A1-A5 reuse this class):
+  use_transformer=False  -> mean-pool tokens instead of Transformer (A2)
+  planes=("axial",)      -> single-plane / axial-only (A1)
+  use_metadata=False     -> drop tabular branch entirely (A3)
+  fusion="concat"        -> ConcatFusion instead of GatedFusion (A4)
+"""
+from __future__ import annotations
+
+import timm
+import torch
+import torch.nn as nn
+
+from .fusion import GatedFusion, ConcatFusion
+
+PLANE_TO_IDX = {"axial": 0, "coronal": 1, "sagittal": 2}
+
+
+class MetadataMLP(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int = 128, dropout: float = 0.3):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, 64), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(64, out_dim), nn.LayerNorm(out_dim),
+        )
+        self.out_dim = out_dim
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class TriFuseAD(nn.Module):
+    def __init__(
+        self,
+        n_classes: int = 3,
+        n_tab_features: int = 7,
+        planes: tuple[str, ...] = ("axial", "coronal", "sagittal"),
+        n_slices: int = 9,
+        backbone: str = "convnext_tiny",
+        embed_dim: int = 768,
+        n_transformer_layers: int = 2,
+        n_heads: int = 8,
+        dropout: float = 0.3,
+        use_transformer: bool = True,
+        use_metadata: bool = True,
+        fusion: str = "gated",
+        pretrained: bool = True,
+    ):
+        super().__init__()
+        self.planes = planes
+        self.n_slices = n_slices
+        self.n_tokens = len(planes) * n_slices
+        self.use_transformer = use_transformer
+        self.use_metadata = use_metadata
+
+        # shared CNN encoder (num_classes=0 -> pooled feature vector)
+        self.encoder = timm.create_model(
+            backbone, pretrained=pretrained, num_classes=0, in_chans=3,
+        )
+        feat_dim = self.encoder.num_features
+        self.proj = nn.Linear(feat_dim, embed_dim) if feat_dim != embed_dim else nn.Identity()
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.slice_pos = nn.Parameter(torch.zeros(1, n_slices, embed_dim))
+        self.plane_emb = nn.Parameter(torch.zeros(1, len(planes), embed_dim))
+        nn.init.trunc_normal_(self.cls_token, std=0.02)
+        nn.init.trunc_normal_(self.slice_pos, std=0.02)
+        nn.init.trunc_normal_(self.plane_emb, std=0.02)
+
+        if use_transformer:
+            layer = nn.TransformerEncoderLayer(
+                d_model=embed_dim, nhead=n_heads, dim_feedforward=embed_dim * 4,
+                dropout=dropout, batch_first=True, activation="gelu", norm_first=True,
+            )
+            self.transformer = nn.TransformerEncoder(layer, num_layers=n_transformer_layers)
+        self.mri_norm = nn.LayerNorm(embed_dim)
+
+        fused_dim = embed_dim
+        if use_metadata:
+            self.tab_mlp = MetadataMLP(n_tab_features, out_dim=128, dropout=dropout)
+            fusion_cls = GatedFusion if fusion == "gated" else ConcatFusion
+            self.fusion = fusion_cls(embed_dim, self.tab_mlp.out_dim, dropout=dropout)
+            fused_dim = self.fusion.out_dim
+
+        self.head = nn.Sequential(
+            nn.Linear(fused_dim, 256), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(256, n_classes),
+        )
+
+    def encode_mri(self, slices: torch.Tensor) -> torch.Tensor:
+        """slices: (B, n_tokens, 3, H, W) -> z_mri (B, embed_dim)."""
+        B, T, C, H, W = slices.shape
+        feats = self.encoder(slices.reshape(B * T, C, H, W))       # (B*T, feat_dim)
+        feats = self.proj(feats).reshape(B, T, -1)                 # (B, T, embed_dim)
+
+        # add slice + plane positional embeddings (tokens ordered plane-major)
+        pos = []
+        for p_idx in range(len(self.planes)):
+            pe = self.slice_pos + self.plane_emb[:, p_idx:p_idx + 1, :]  # (1, n_slices, D)
+            pos.append(pe)
+        pos = torch.cat(pos, dim=1)                                # (1, T, D)
+        feats = feats + pos
+
+        if self.use_transformer:
+            cls = self.cls_token.expand(B, -1, -1)
+            seq = torch.cat([cls, feats], dim=1)                   # (B, 1+T, D)
+            seq = self.transformer(seq)
+            z = seq[:, 0]                                          # CLS
+        else:
+            z = feats.mean(dim=1)                                  # mean-pool (A2)
+        return self.mri_norm(z)
+
+    def forward(self, slices: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
+        z_mri = self.encode_mri(slices)
+        if self.use_metadata:
+            assert tab is not None, "metadata branch enabled but tab is None"
+            z_tab = self.tab_mlp(tab)
+            z = self.fusion(z_mri, z_tab)
+        else:
+            z = z_mri
+        return self.head(z)