| """926/D — fMRI-Shape: the same input controls, sets and power as for EEG. |
| |
| Processed fMRI-Shape (npy_data, as in the repository), public subjects 1-4, the |
| leakage-safe learned L=128 category decoders (3 seeds, results/fmri_shape_bottleneck_leakage_safe). |
| No 3D generator exists for fMRI-Shape, so the decoder is classify -> train-only |
| category medoid, with ShapeNetCore.v2 PC15k point clouds and medoids exactly as in |
| 9.24torun/T2 (1024 points, unit sphere, Chamfer-L2; 101/104 test objects with a point cloud). |
| |
| Inputs (wrong = (c + 1) mod 13): |
| paired the object's own fMRI sample |
| same_category_swap the next test object of the same category (cyclic within the test list) |
| target_mean mean of the train-split samples of the target category (same subject) |
| wrong_mean same for the wrong category |
| Each input is normalised like the training data ((x - mean) / std per sample). |
| """ |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| REFS = Path("/home/hubin/workspace/July/brain3d_refs") |
| sys.path.insert(0, str(REFS)); sys.path.insert(0, str(REFS / "scripts")) |
| import train_fmri_shape_bottleneck as tf |
|
|
| tf.ROOT, tf.DATA = REFS, REFS / "data" / "fMRI-Shape" |
| SUBJECTS = ["sub-0001", "sub-0002", "sub-0003", "sub-0004"] |
| GEOM = Path("/home/hubin/JAMIETSENG/9.24torun/results/T2_fmir_instance_chamfer/instance_geometry_p1024.npz") |
| OUT = Path("/home/hubin/926/results/D") |
| CONDS = ["paired", "same_category_swap", "target_mean", "wrong_mean"] |
|
|
|
|
| def load(subject, row): |
| c, u = row.split("/", 1) |
| v = np.load(tf.DATA / subject / "npy_data" / c / f"{u}.npy").astype(np.float32) |
| return v |
|
|
|
|
| def norm(v): |
| return (v - v.mean()) / max(float(v.std()), 1e-6) |
|
|
|
|
| def main(): |
| from scipy import stats |
| z = np.load(GEOM, allow_pickle=True) |
| err, valid = z["errors"], z["valid"] |
| dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| res = {"per_subject": {}, "conditions": CONDS} |
| rows_all = [] |
| for subj in SUBJECTS: |
| test = tf.FMRIShapeDataset(subj, "test") |
| train = tf.FMRIShapeDataset(subj, "train") |
| cats = test.categories |
| y = np.array([test.category_index[r.split("/", 1)[0]] for r in test.rows]) |
| X = np.stack([norm(load(subj, r)) for r in test.rows]) |
| means = {} |
| for k, c in enumerate(cats): |
| rs = [r for r in train.rows if r.startswith(c + "/")] |
| means[k] = norm(np.mean([norm(load(subj, r)) for r in rs], 0)) |
| partner = [] |
| for i in range(len(y)): |
| same = [j for j in range(len(y)) if y[j] == y[i]] |
| partner.append(same[(same.index(i) + 1) % len(same)]) |
| inp = {"paired": X, "same_category_swap": X[partner], |
| "target_mean": np.stack([means[int(c)] for c in y]), |
| "wrong_mean": np.stack([means[int((c + 1) % len(cats))] for c in y])} |
| per_seed = {} |
| for seed in (0, 1, 2): |
| ck = torch.load(REFS / f"results/fmri_shape_bottleneck_leakage_safe/{subj}_learned_L128_s{seed}/model.pt", |
| map_location="cpu", weights_only=False) |
| model = tf.FMRIBottleneck(128, len(cats), "learned").to(dev) |
| model.load_state_dict(ck["model"]); model.eval() |
| per_seed[seed] = {} |
| for cond in CONDS: |
| with torch.inference_mode(): |
| P = torch.cat([model(torch.from_numpy(inp[cond][i:i + 32]).to(dev)).softmax(-1).cpu() |
| for i in range(0, len(y), 32)]).double().numpy() |
| rank = (P > P[np.arange(len(y)), y][:, None]).sum(1) |
| pick = P.argmax(1) |
| ch = np.where(valid, err[np.arange(len(y)), pick], np.nan) |
| oracle = np.where(valid, err[np.arange(len(y)), y], np.nan) |
| per_seed[seed][cond] = {"top1": float((rank < 1).mean()), "top3": float((rank < 3).mean()), |
| "top5": float((rank < 5).mean()), |
| "classify_medoid_chamfer": float(np.nanmean(ch)), |
| "oracle_medoid_chamfer": float(np.nanmean(oracle))} |
| for i in range(len(y)): |
| rows_all.append({"subject": subj, "seed": seed, "condition": cond, "object": test.rows[i], |
| "category": int(y[i]), "decoded": int(pick[i]), "rank": int(rank[i]), |
| "chamfer_l2": None if not valid[i] else float(ch[i])}) |
| res["per_subject"][subj] = {c: {k: float(np.mean([per_seed[s][c][k] for s in per_seed])) for k in per_seed[0][c]} |
| for c in CONDS} |
| print(f"fMRI {subj}: " + " | ".join(f"{c} top1={res['per_subject'][subj][c]['top1']:.3f} " |
| f"ch={res['per_subject'][subj][c]['classify_medoid_chamfer']:.4f}" |
| for c in CONDS), flush=True) |
|
|
| deltas = {} |
| for cond in CONDS[1:]: |
| deltas[cond] = {} |
| for k in ("classify_medoid_chamfer", "top1", "top5"): |
| d = np.array([res["per_subject"][s][cond][k] - res["per_subject"][s]["paired"][k] for s in SUBJECTS]) |
| n, m, sd = len(d), float(d.mean()), float(d.std(ddof=1)) |
| half = stats.t.ppf(0.975, n - 1) * sd / np.sqrt(n) |
| deltas[cond][k] = {"delta": m, "sd_subject": sd, "ci95_t": [m - half, m + half], |
| "per_subject": d.tolist(), |
| "worse_subjects": int((d > 0).sum() if k.endswith("chamfer") else (d < 0).sum())} |
| res["delta_vs_paired"] = deltas |
| sd = deltas["same_category_swap"]["classify_medoid_chamfer"]["sd_subject"] |
| grid = np.linspace(0, max(0.02, 6 * sd), 61) |
|
|
| def power(delta, n): |
| df, nc = n - 1, delta / (sd / np.sqrt(n)) |
| tc = stats.t.ppf(0.975, df) |
| return float(stats.nct.sf(tc, df, nc) + stats.nct.cdf(-tc, df, nc)) |
| res["power_swap"] = {"between_subject_sd": sd, "deltas": grid.tolist(), |
| "power": {str(n): [power(x, n) for x in grid] for n in (4, 8, 16)}, |
| "mde_80pct": {str(n): next((float(x) for x in grid if power(x, n) >= 0.8), None) for n in (4, 8, 16)}} |
| t2 = json.load(open("/home/hubin/JAMIETSENG/9.24torun/results/T2_fmir_instance_chamfer/results.json")) |
| res["sets_from_T2"] = {"K=10": t2["allocations"]["K=10"], "note": "set recall / instance Chamfer of the fMRI set " |
| "decoder (collective posterior, 3 seeds) from 9.24torun/T2"} |
| res["n_subjects"] = len(SUBJECTS) |
| res["unit"] = "subject (n = 4 public subjects); per-subject values are means over 3 decoder seeds" |
| OUT.mkdir(parents=True, exist_ok=True) |
| json.dump(res, open(OUT / "fmri.json", "w"), indent=1, default=float) |
| import csv |
| with open(OUT / "fmri_per_object.csv", "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(rows_all[0])); w.writeheader(); w.writerows(rows_all) |
| print(json.dumps({c: {k: round(v["delta"], 4) for k, v in deltas[c].items()} for c in deltas}), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
