| """926/B — is the category-mean gain just a better input? |
| |
| Frozen released 200k point-diffusion generator (encoder + PVN), 200 denoising |
| steps, batch 48, sampling seed fixed per batch start, so every condition of an |
| object shares its initial noise. Targets: held-out objects 08-09 (144). |
| |
| Conditions (wrong category = (c + 1) mod 72 everywhere): |
| paired_4avg mean of the 4 test trials of the object (the standard `real` input) |
| paired_single first test trial of the object |
| same_category_swap 4-trial mean of the other held-out object of the same category |
| samecat_rand4 mean of 4 random train trials of the target category |
| wrongcat_rand4 mean of 4 random train trials of the wrong category |
| target_trialmatched4 mean of 4 train trials of the target category, 4 different train objects |
| wrong_trialmatched4 same for the wrong category |
| target_within mean of all 16 train trials of the target category, same subject |
| wrong_within same for the wrong category |
| target_cross target-category mean pooled over all 12 subjects |
| wrong_cross same for the wrong category |
| target_loso target-category mean over the 11 other subjects |
| wrong_loso same for the wrong category |
| paired_match_varnorm paired_4avg with per-channel mean/std and Frobenius norm set to target_within |
| paired_match_spectrum paired_4avg with per-channel amplitude spectrum of target_within (phase kept) |
| paired_match_cov paired_4avg whitened and re-coloured to the channel covariance of target_within |
| target_latent encoder outputs replaced by the mean encoder output over the 16 train trials |
| of the target category (same subject) |
| wrong_latent same for the wrong category |
| """ |
| import argparse |
| import json |
| import os |
| import sys |
| import tempfile |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| REFS = Path(os.environ.get("BB3D_REFS", "/home/hubin/workspace/July/brain3d_refs")) |
| sys.path.insert(0, str(REFS / "third_party" / "neuro-3D")) |
| sys.path.insert(0, str(REFS / "scripts")) |
| import evaluate_shape_diffusion_controls as ev |
|
|
| ev.ROOT, ev.REPO, ev.DATA = REFS, REFS / "third_party" / "neuro-3D", REFS / "data" / "EEG-3D" |
| DATA = ev.DATA |
| SUBJECTS = [f"sub{i:02d}" for i in range(1, 13)] |
| CONDITIONS = ["paired_4avg", "paired_single", "same_category_swap", "samecat_rand4", "wrongcat_rand4", |
| "target_trialmatched4", "wrong_trialmatched4", "target_within", "wrong_within", |
| "target_cross", "wrong_cross", "target_loso", "wrong_loso", |
| "paired_match_varnorm", "paired_match_spectrum", "paired_match_cov", |
| "target_latent", "wrong_latent"] |
|
|
|
|
| def raw(subject, split): |
| d = DATA / "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 category_means(cache): |
| """Per-subject train category means (72, 64, T) for both EEG streams, cached.""" |
| cache.mkdir(parents=True, exist_ok=True) |
| out = {} |
| for s in SUBJECTS: |
| p = cache / f"catmean_{s}.npz" |
| if not p.exists(): |
| a, b = raw(s, "train") |
| np.savez(p, dyn=a.mean((1, 2)), sta=b.mean((1, 2))) |
| z = np.load(p) |
| out[s] = (z["dyn"], z["sta"]) |
| return out |
|
|
|
|
| def match_varnorm(x, m): |
| y = (x - x.mean(-1, keepdims=True)) / (x.std(-1, keepdims=True) + 1e-8) * m.std(-1, keepdims=True) \ |
| + m.mean(-1, keepdims=True) |
| return y * (np.linalg.norm(m) / (np.linalg.norm(y) + 1e-8)) |
|
|
|
|
| def match_spectrum(x, m): |
| X, M = np.fft.rfft(x, axis=-1), np.fft.rfft(m, axis=-1) |
| return np.fft.irfft(np.abs(M) * np.exp(1j * np.angle(X)), n=x.shape[-1], axis=-1).astype(np.float32) |
|
|
|
|
| def _sqrtm(c, inv=False): |
| w, v = np.linalg.eigh(c) |
| w = np.clip(w, 1e-8 * w.max(), None) |
| return (v * (w ** (-0.5 if inv else 0.5))) @ v.T |
|
|
|
|
| def match_cov(x, m): |
| xc, mc = x - x.mean(-1, keepdims=True), m - m.mean(-1, keepdims=True) |
| cx, cm = xc @ xc.T / x.shape[-1], mc @ mc.T / m.shape[-1] |
| eps = 1e-6 * np.trace(cx) / len(cx) |
| return (_sqrtm(cm + eps * np.eye(len(cm))) @ _sqrtm(cx + eps * np.eye(len(cx)), inv=True) @ xc |
| + m.mean(-1, keepdims=True)).astype(np.float32) |
|
|
|
|
| class Inputs: |
| def __init__(self, subject, means, seed): |
| self.s = subject |
| self.tr = raw(subject, "train") |
| self.te = raw(subject, "test") |
| self.own = means[subject] |
| self.cross = tuple(np.mean([means[s][k] for s in SUBJECTS], 0) for k in (0, 1)) |
| self.loso = tuple(np.mean([means[s][k] for s in SUBJECTS if s != subject], 0) for k in (0, 1)) |
| self.seed = seed |
|
|
| def _rng(self, cond, c, o): |
| return np.random.default_rng([self.seed, SUBJECTS.index(self.s), 1 + CONDITIONS.index(cond), c, o]) |
|
|
| def get(self, cond, c, o): |
| """EEG (dynamic, static) for test object o (0/1) of category c.""" |
| w = (c + 1) % 72 |
| if cond in ("paired_4avg", "target_latent", "wrong_latent"): |
| return tuple(a[c, o].mean(0) for a in self.te) |
| if cond == "paired_single": |
| return tuple(a[c, o, 0] for a in self.te) |
| if cond == "same_category_swap": |
| return tuple(a[c, 1 - o].mean(0) for a in self.te) |
| if cond in ("samecat_rand4", "wrongcat_rand4"): |
| k = c if cond == "samecat_rand4" else w |
| pick = self._rng(cond, c, o).choice(16, 4, replace=False) |
| return tuple(a[k].reshape(16, *a.shape[3:])[pick].mean(0) for a in self.tr) |
| if cond in ("target_trialmatched4", "wrong_trialmatched4"): |
| k = c if cond.startswith("target") else w |
| r = self._rng(cond, c, o) |
| objs, trials = r.choice(8, 4, replace=False), r.integers(0, 2, 4) |
| return tuple(a[k, objs, trials].mean(0) for a in self.tr) |
| for tag, src in (("within", self.own), ("cross", self.cross), ("loso", self.loso)): |
| if cond in (f"target_{tag}", f"wrong_{tag}"): |
| k = c if cond.startswith("target") else w |
| return src[0][k], src[1][k] |
| if cond.startswith("paired_match_"): |
| fn = {"varnorm": match_varnorm, "spectrum": match_spectrum, "cov": match_cov}[cond.split("_")[-1]] |
| x = tuple(a[c, o].mean(0) for a in self.te) |
| return tuple(fn(xi, mi[c]).astype(np.float32) for xi, mi in zip(x, self.own)) |
| raise ValueError(cond) |
|
|
|
|
| def atomic_json(path, payload): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with tempfile.NamedTemporaryFile("w", dir=path.parent, prefix=path.name, suffix=".tmp", delete=False) as h: |
| json.dump(payload, h) |
| tmp = Path(h.name) |
| os.replace(tmp, path) |
|
|
|
|
| def build_model(subject, device): |
| ckpt = DATA / "model" / "point_generate" / "shape" / subject / "resumable_200000steps" / "checkpoint-200000.pth" |
| state = torch.load(ckpt, map_location="cpu", weights_only=False) |
| model = ev.EEGTo3DDiffusionModel( |
| beta_start=1e-5, beta_end=8e-3, beta_schedule="linear", sub=subject, generate_type="shape", |
| retri_pretrain_model=f"{DATA}/model/retraival/{subject}/{ev.encoder_name(int(subject[3:]))}/", |
| point_cloud_model_embed_dim=64, in_channels=1027, out_channels=3) |
| model.load_state_dict(state["model"]) |
| return model.eval().to(device), str(ckpt), int(state.get("step", -1)) |
|
|
|
|
| def latent_means(model, inp, device): |
| """Mean encoder outputs over the 16 train trials of each category (same subject).""" |
| outs = [] |
| with torch.inference_mode(): |
| for c in range(72): |
| a = torch.from_numpy(inp.tr[0][c].reshape(16, 64, -1)).to(device) |
| b = torch.from_numpy(inp.tr[1][c].reshape(16, 64, -1)).to(device) |
| o = model.meta_eeg_video(a, b) |
| outs.append([t.float().mean(0) for t in o]) |
| return [torch.stack([outs[c][i] for c in range(72)]) for i in range(len(outs[0]))] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--subject", required=True) |
| ap.add_argument("--conditions", default=",".join(CONDITIONS)) |
| ap.add_argument("--steps", type=int, default=200) |
| ap.add_argument("--batch-size", type=int, default=48) |
| ap.add_argument("--seed", type=int, default=20260722) |
| ap.add_argument("--cache", default="/home/hubin/926/cache") |
| ap.add_argument("--out", required=True) |
| a = ap.parse_args() |
| device = torch.device("cuda") |
| model, ckpt, step = build_model(a.subject, device) |
| means = category_means(Path(a.cache)) |
| inp = Inputs(a.subject, means, a.seed) |
| test = ev.AllDataFeatureTwoEEG(f"{DATA}/", sub_list=[a.subject], train=False, test_mean=True, |
| aug_data=False, load_point_cloud=True) |
| items = [test[i] for i in range(len(test))] |
| names = [str(it["name"]) for it in items] |
| cats = [int(it["cls_label"]) for it in items] |
| obj = [0 if n.endswith("_08") else 1 for n in names] |
| assert all(n.endswith(("_08", "_09")) for n in names) |
| all_pf = test.color_point_features[:, 0].float().to(device) |
| all_vf = test.color_video_features[:, 0].float().to(device) |
|
|
| override = {"value": None} |
| model.meta_eeg_video.register_forward_hook( |
| lambda mod, args, out: tuple(override["value"]) if override["value"] is not None else out) |
| lat = None |
|
|
| out = Path(a.out) |
| rows = json.loads(out.read_text())["rows"] if out.exists() else [] |
| done = {(r["condition"], r["name"]) for r in rows} |
| for cond in a.conditions.split(","): |
| if all((cond, n) for n in names) and all((cond, n) in done for n in names): |
| continue |
| t0 = time.time() |
| if cond.endswith("_latent") and lat is None: |
| lat = latent_means(model, inp, device) |
| for start in range(0, len(items), a.batch_size): |
| idx = list(range(start, min(start + a.batch_size, len(items)))) |
| if all((cond, names[i]) in done for i in idx): |
| continue |
| batch = ev.default_collate([items[i] for i in idx]) |
| eeg = [inp.get(cond, cats[i], obj[i]) for i in idx] |
| dyn = torch.from_numpy(np.stack([e[0] for e in eeg])).float().to(device) |
| sta = torch.from_numpy(np.stack([e[1] for e in eeg])).float().to(device) |
| if cond.endswith("_latent"): |
| lab = torch.tensor([c if cond.startswith("target") else (c + 1) % 72 for c in (cats[i] for i in idx)]) |
| override["value"] = [t[lab.to(device)] for t in lat] |
| torch.manual_seed(a.seed + start) |
| torch.cuda.manual_seed_all(a.seed + start) |
| pc = batch["point_cloud"].float()[:, :, :3].to(device) |
| feats = {"point_features": batch["color_point_fea"].float().to(device), |
| "video_features": batch["color_video_fea"].float().to(device), |
| "point_features_all": all_pf, "video_features_all": all_vf} |
| with torch.inference_mode(): |
| pred, _ = model(pc, dyn, sta, mode="sample", shape_c=None, fea_list=feats, |
| labels=batch["cls_label"].to(device), return_sample_every_n_steps=-1, |
| num_inference_steps=a.steps, disable_tqdm=True) |
| override["value"] = None |
| p, t = pred.float().cpu().numpy(), pc.cpu().numpy() |
| for j, i in enumerate(idx): |
| rows.append({"subject": a.subject, "condition": cond, "name": names[i], "category": cats[i], |
| **ev.metrics(p[j], t[j])}) |
| done.add((cond, names[i])) |
| atomic_json(out, {"subject": a.subject, "checkpoint": ckpt, "checkpoint_step": step, |
| "inference_steps": a.steps, "batch_size": a.batch_size, "seed": a.seed, |
| "rows": rows}) |
| print(f"B subject={a.subject} condition={cond} done in {time.time() - t0:.0f}s", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
