code/b_inputs.py

"""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  # noqa: E402

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")          # (72, 8, 2, 64, T)
        self.te = raw(subject, "test")           # (72, 2, 4, 64, T)
        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()