| """926/C — the attribution fingerprint on more than one decoder. |
| |
| Validation-safe EEG encoders (objects 00-05 train, 06-07 epoch selection), five |
| training seeds (0-2 existing, 3-4 trained for 926 with the same script). Test: |
| held-out objects 08-09, EEG repetitions averaged (test_mean), 12 subjects. |
| |
| Inputs, all fed through the same encoder (wrong = (c + 1) mod 72): |
| paired 4-trial mean of the object |
| same_category_swap 4-trial mean of the other held-out object of the category |
| target_mean mean of the 16 train trials (objects 00-07) of the target category, same subject |
| wrong_mean same for the wrong category |
| |
| Three small decoders on top of the frozen encoder: |
| classify_medoid MAP category -> its train medoid (results/p0_category_geometry) |
| latent_regression ridge from encoder features to the existing CLIP point embedding |
| (data/EEG-3D/clip_feature.pth, fit on train objects 00-05), |
| decoded as the train object (00-05) nearest in that embedding |
| retrieval train object (00-05) whose EEG feature is nearest (cosine) |
| Geometry: same as 926/A (512 points, centred, unit sphere, Chamfer-L2, F@0.1, EMD-256). |
| Readout per seed: top-1/5/10, MRR, NLL on paired input, single subject and 12-subject pooled. |
| """ |
| import argparse |
| import csv |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| sys.path.insert(0, str(Path(__file__).parent)) |
| from a_sets import REFS, chamfer_matrix, emd_matrix, load_obj |
|
|
| sys.path.insert(0, str(REFS / "third_party" / "neuro-3D")) |
| SUBJECTS = [f"sub{i:02d}" for i in range(1, 13)] |
| ENC = {0: REFS / "results/encoder_validation_safe", 1: REFS / "results/encoder_validation_safe_seed1", |
| 2: REFS / "results/encoder_validation_safe_seed2", 3: Path("/home/hubin/926/encoders/seed3"), |
| 4: Path("/home/hubin/926/encoders/seed4")} |
| CONDS = ["paired", "same_category_swap", "target_mean", "wrong_mean"] |
| DECODERS = ["classify_medoid", "latent_regression", "retrieval"] |
|
|
|
|
| def raw(subject, split): |
| d = REFS / "data/EEG-3D/EEGdata" / subject |
| return (np.load(d / f"{subject}_{split}_data_6s_100Hz.npy").astype(np.float32), |
| np.load(d / f"{subject}_{split}_data_1s_250Hz.npy").astype(np.float32)) |
|
|
|
|
| def inputs(subject): |
| tr, te = raw(subject, "train"), raw(subject, "test") |
| c = np.repeat(np.arange(72), 2) |
| o = np.tile([0, 1], 72) |
| x = {"paired": tuple(a.mean(2)[c, o] for a in te), |
| "same_category_swap": tuple(a.mean(2)[c, 1 - o] for a in te)} |
| cm = tuple(a.mean((1, 2)) for a in tr) |
| x["target_mean"] = tuple(m[c] for m in cm) |
| x["wrong_mean"] = tuple(m[(c + 1) % 72] for m in cm) |
| gallery = tuple(a[:, :6].mean(2).reshape(72 * 6, 64, -1) for a in tr) |
| return x, gallery |
|
|
|
|
| @torch.inference_mode() |
| def encode(model, long_, short, device): |
| P, F = [], [] |
| for i in range(0, len(long_), 72): |
| f1, logits, _, _ = model(torch.from_numpy(long_[i:i + 72]).to(device), torch.from_numpy(short[i:i + 72]).to(device)) |
| P.append(logits.float().softmax(-1).cpu().numpy()); F.append(f1.float().cpu().numpy()) |
| return np.concatenate(P).astype(np.float64), np.concatenate(F).astype(np.float64) |
|
|
|
|
| def readout(P, y): |
| rank = (P > P[np.arange(len(y)), y][:, None]).sum(1) |
| return {"top1": float((rank < 1).mean()), "top5": float((rank < 5).mean()), "top10": float((rank < 10).mean()), |
| "mrr": float((1.0 / (rank + 1)).mean()), "nll": float(-np.log(np.clip(P[np.arange(len(y)), y], 1e-12, 1)).mean())} |
|
|
|
|
| def geometry(work): |
| p = work / "c_gallery_geometry.npz" |
| if p.exists(): |
| return dict(np.load(p)) |
| g = np.load(work / "geometry.npz", allow_pickle=True) |
| names = [f"{n.rsplit('_', 1)[0]}_{j:02d}" for n in g["names"][::2] for j in range(6)] |
| gal = np.stack([load_obj(n) for n in names]) |
| tgt = np.stack([load_obj(n) for n in g["names"]]) |
| ch, f = chamfer_matrix(tgt, gal) |
| out = {"gal_ch": ch, "gal_f": f, "gal_emd": emd_matrix(tgt, gal), "gal_names": np.array(names)} |
| np.savez(p, **out) |
| return out |
|
|
|
|
| def subject_ci(x, n_boot, rng): |
| idx = rng.integers(0, len(x), (n_boot, len(x))) |
| d = x[idx].mean(1) |
| return float(x.mean()), [float(np.quantile(d, 0.025)), float(np.quantile(d, 0.975))] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", default="/home/hubin/926/results/C") |
| ap.add_argument("--seeds", default="0,1,2,3,4") |
| ap.add_argument("--ridge", type=float, default=10.0) |
| ap.add_argument("--bootstrap", type=int, default=10000) |
| ap.add_argument("--seed", type=int, default=20260722) |
| a = ap.parse_args() |
| out = Path(a.out); out.mkdir(parents=True, exist_ok=True) |
| work = Path("/home/hubin/926/cache") |
| g = np.load(work / "geometry.npz", allow_pickle=True) |
| gg = geometry(work) |
| y = g["true"] |
| clip = torch.load(REFS / "data/EEG-3D/clip_feature.pth", map_location="cpu", weights_only=False) |
| Z = np.stack([clip[str(n).split("_", 1)[1]]["point"].float().numpy() for n in gg["gal_names"]]).astype(np.float64) |
| Zn = Z / np.linalg.norm(Z, axis=1, keepdims=True) |
| from eeg_data_process.extract_eeg_feature import VideoImageEEGClassifyColor3 |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| seeds = [int(s) for s in a.seeds.split(",")] |
|
|
| rows, seed_rows, pooled_P = [], [], {s: [] for s in seeds} |
| for seed in seeds: |
| for si, subj in enumerate(SUBJECTS): |
| ck = torch.load(ENC[seed] / subj / "best_validation.pt", map_location="cpu", weights_only=False) |
| model = VideoImageEEGClassifyColor3(num_channels=64, sequence_length=600, sequence_length2=250, |
| num_latents=1024, cls_num=72) |
| model.load_state_dict(ck["model"]); model.eval().to(device) |
| x, gal = inputs(subj) |
| _, Fg = encode(model, *gal, device) |
| Fgn = Fg / np.linalg.norm(Fg, axis=1, keepdims=True) |
| mu, sd = Fg.mean(0), Fg.std(0) + 1e-6 |
| Xs = (Fg - mu) / sd |
| W = np.linalg.solve(Xs.T @ Xs + a.ridge * np.eye(Xs.shape[1]), Xs.T @ (Z - Z.mean(0))) |
| for cond in CONDS: |
| P, F = encode(model, *x[cond], device) |
| if cond == "paired": |
| seed_rows.append({"seed": seed, "subject": subj, "pool": "single", **readout(P, y)}) |
| pooled_P[seed].append(P) |
| zhat = ((F - mu) / sd) @ W + Z.mean(0) |
| pick = {"classify_medoid": P.argmax(1), |
| "latent_regression": (zhat / np.linalg.norm(zhat, axis=1, keepdims=True) @ Zn.T).argmax(1), |
| "retrieval": ((F / np.linalg.norm(F, axis=1, keepdims=True)) @ Fgn.T).argmax(1)} |
| for dec, k in pick.items(): |
| src = ("target_ch", "target_f", "target_emd") if dec == "classify_medoid" else ("gal_ch", "gal_f", "gal_emd") |
| M = g if dec == "classify_medoid" else gg |
| cat = k if dec == "classify_medoid" else k // 6 |
| for i in range(144): |
| rows.append({"seed": seed, "subject": subj, "decoder": dec, "condition": cond, |
| "object": str(g["names"][i]), "category": int(y[i]), |
| "decoded_category": int(cat[i]), "category_hit": int(cat[i] == y[i]), |
| "chamfer_l2": float(M[src[0]][i, k[i]]), "f01": float(M[src[1]][i, k[i]]), |
| "emd_256": float(M[src[2]][i, k[i]])}) |
| print(f"C seed={seed} {subj} top5={seed_rows[-1]['top5']:.3f}", flush=True) |
| del model |
| seed_rows.append({"seed": seed, "subject": "pooled12", "pool": "pooled", **readout(np.mean(pooled_P[seed], 0), y)}) |
|
|
| with open(out / "seeds.csv", "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(seed_rows[0])); w.writeheader(); w.writerows(seed_rows) |
| with open(out / "per_object.csv", "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(rows[0])); w.writeheader(); w.writerows(rows) |
|
|
| rng = np.random.default_rng(a.seed) |
| import pandas as pd |
| df = pd.DataFrame(rows) |
| fingerprint = {} |
| for dec in DECODERS: |
| fingerprint[dec] = {} |
| base = df[(df.decoder == dec) & (df.condition == "paired")].groupby("subject")[["chamfer_l2", "f01", "emd_256", "category_hit"]].mean() |
| for cond in CONDS: |
| cur = df[(df.decoder == dec) & (df.condition == cond)].groupby("subject")[["chamfer_l2", "f01", "emd_256", "category_hit"]].mean() |
| e = {"mean": {k: float(cur[k].mean()) for k in cur}} |
| if cond != "paired": |
| for k in ("chamfer_l2", "f01", "emd_256"): |
| d = (cur[k] - base[k]).values |
| m, ci = subject_ci(d, a.bootstrap, rng) |
| worse = int((d > 0).sum()) if k != "f01" else int((d < 0).sum()) |
| e[f"delta_{k}"] = {"delta": m, "ci95_subject": ci, "subjects_worse": worse} |
| fingerprint[dec][cond] = e |
| sr = pd.DataFrame(seed_rows) |
| single = sr[sr["pool"] == "single"].groupby("seed")[["top1", "top5", "top10", "mrr", "nll"]].mean() |
| pooled = sr[sr["pool"] == "pooled"].set_index("seed")[["top1", "top5", "top10", "mrr", "nll"]] |
| readouts = {"single_subject_mean_per_seed": single.to_dict("index"), |
| "single_subject_mean_std_over_seeds": {k: [float(single[k].mean()), float(single[k].std(ddof=1))] for k in single}, |
| "pooled12_per_seed": pooled.to_dict("index"), |
| "pooled12_mean_std_over_seeds": {k: [float(pooled[k].mean()), float(pooled[k].std(ddof=1))] for k in pooled}, |
| "chance": {"top1": 1 / 72, "top5": 5 / 72, "top10": 10 / 72, "nll": float(np.log(72))}} |
| res = {"experiment": "926_C_decoders", "seeds": seeds, "decoders": DECODERS, "conditions": CONDS, |
| "fingerprint_seed_mean": fingerprint, "readout": readouts, |
| "note": "subject = unit; per-subject values are means over the 5 encoder seeds and 144 objects; " |
| "delta = condition - paired (positive Chamfer/EMD = worse); CI resamples subjects", |
| "ridge": a.ridge, "bootstrap": a.bootstrap} |
| json.dump(res, open(out / "results.json", "w"), indent=1, default=float) |
| print("C done", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
