"""Run every probe for one feature source (SiT checkpoint, teacher encoder, or VAE-latent baseline).""" from __future__ import annotations import math import time import numpy as np import torch from . import probes as P from .common import CACHE, log BATCH = 128 class DataBank: """Fixed inputs shared by all sources: latents, noise bank, images, labels, folds, depth.""" def __init__(self, device="cuda", need_train=True): self.device = device self.splits = ["inet_eval", "inet_latfit", "nyu"] + (["inet_train"] if need_train else []) self.lat, self.eps, self.fold, self.img = {}, {}, {}, {} for s in self.splits: self.lat[s] = torch.from_numpy(np.load(CACHE / f"{s}_lat.npy")).to(device) self.eps[s] = torch.from_numpy(np.load(CACHE / f"{s}_eps.npy")).to(device) self.fold[s] = torch.from_numpy(np.load(CACHE / f"{s}_fold.npy")).to(device) self.img[s] = np.load(CACHE / f"{s}_img.npy", mmap_mode="r") self.lbl = {s: torch.from_numpy(np.load(CACHE / f"{s}_lbl.npy")).to(device) for s in self.splits if s.startswith("inet")} self.sub5k = torch.from_numpy(np.load(CACHE / "inet_eval_sub5k.npy")).to(device) split = np.load(CACHE / "nyu_split.npy") self.nyu_train = np.flatnonzero(split == 0) self.nyu_test = np.flatnonzero(split == 1) self.depth = torch.from_numpy(np.load(CACHE / "nyu_depth.npy")).to(device) # depth design matrices for the train images (model independent) A = P.upsample_matrix(device=device) G, b, c, n = [], [], [], [] for i in range(0, len(self.nyu_train), 64): idx = self.nyu_train[i:i + 64] g_, b_, c_, n_ = P.depth_design(self.depth[idx], A) G.append(g_); b.append(b_); c.append(c_); n.append(n_) self.dG, self.db, self.dc, self.dn = torch.cat(G), torch.cat(b), torch.cat(c), torch.cat(n) # NYU train fold: reuse the nyu fold array restricted to train images self.nyu_train_fold = self.fold["nyu"][torch.from_numpy(self.nyu_train).to(device)] del A torch.cuda.empty_cache() def images(self, split, idx): return torch.from_numpy(np.ascontiguousarray(self.img[split][idx])).to(self.device) def _batches(n, bs=BATCH): for i in range(0, n, bs): yield np.arange(i, min(n, i + bs)) class Source: """Wraps a feature function. kind: 'latent' (SiT / VAE: takes x0, eps, s) or 'image' (teacher).""" def __init__(self, name, fn, kind, blocks, svals): self.name, self.fn, self.kind, self.blocks, self.svals = name, fn, kind, list(blocks), list(svals) def feats(self, bank: DataBank, split, idx, s): if self.kind == "latent": ti = torch.from_numpy(idx).to(bank.device) return self.fn(bank.lat[split][ti], bank.eps[split][ti], s) return [self.fn.tokens(bank.images(split, idx))] def run_source(src: Source, bank: DataBank, seeds=(0, 1, 2), tasks=("depth", "latent", "cls", "cknna", "rank"), teacher_sub5k=None, cls_epochs=60, timer=None, cknna_metric="cknna_teacher"): """Returns (rows, extra). rows: dicts with layer, s, task, metric, mean, std, n.""" rows, extra = [], {"timing": {}, "choices": []} L = len(src.blocks) for s in src.svals: s_lab = "clean" if s is None else s t_s = time.time() def add(layer, task, metric, vals): v = np.asarray(vals, dtype=float) rows.append(dict(layer=layer, s=s_lab, task=task, metric=metric, mean=float(v.mean()), std=float(v.std(ddof=1)) if len(v) > 1 else float("nan"), n=len(v))) # ---------------- NYU depth if "depth" in tasks: t0 = time.time() ntr = len(bank.nyu_train) dim = None stats = None for bi in _batches(ntr, 64): idx = bank.nyu_train[bi] f = src.feats(bank, "nyu", idx, s) if stats is None: dim = f[0].shape[-1] stats = P.RidgeStats(L, dim, 1, device=bank.device) ti = torch.from_numpy(bi).to(bank.device) stats.add_weighted(f, bank.dG[ti], bank.db[ti], bank.dc[ti], bank.dn[ti], bank.nyu_train_fold[ti]) Ws = {(l, sd): stats.fit_seed(l, sd) for l in range(L) for sd in seeds} dref = stats.centre.ref del stats mets = {(l, sd): [] for l in range(L) for sd in seeds} for bi in _batches(len(bank.nyu_test), 64): idx = bank.nyu_test[bi] f = src.feats(bank, "nyu", idx, s) dep = bank.depth[torch.from_numpy(idx).to(bank.device)] for l in range(L): for sd in seeds: pred = P.RidgeStats.predict(f[l], Ws[(l, sd)][0], dref[l])[..., 0] mets[(l, sd)] += P.depth_metrics(pred, dep) for l in range(L): for m in ("rmse", "delta1", "absrel", "rmse_log"): add(src.blocks[l], "nyu_depth", m, [np.mean([d[m] for d in mets[(l, sd)]]) for sd in seeds]) extra["choices"].append(dict(s=s_lab, layer=src.blocks[l], task="nyu_depth", alphas=[Ws[(l, sd)][1] for sd in seeds])) extra["timing"][f"depth_s{s_lab}"] = time.time() - t0 # ---------------- latent reconstruction (fit on inet_latfit, test on inet_eval) W_lat = None if "latent" in tasks: t0 = time.time() stats = None n = len(bank.lat["inet_latfit"]) for bi in _batches(n): f = src.feats(bank, "inet_latfit", bi, s) ti = torch.from_numpy(bi).to(bank.device) y = _clean_patches(bank.lat["inet_latfit"][ti]) if stats is None: stats = P.RidgeStats(L, f[0].shape[-1], 16, device=bank.device) stats.add_tokens(f, y, bank.fold["inet_latfit"][ti]) W_lat = {(l, sd): stats.fit_seed(l, sd) for l in range(L) for sd in seeds} lref = stats.centre.ref del stats for l in range(L): extra["choices"].append(dict(s=s_lab, layer=src.blocks[l], task="latent_recon", alphas=[W_lat[(l, sd)][1] for sd in seeds])) extra["timing"][f"latent_fit_s{s_lab}"] = time.time() - t0 # ---------------- inet_eval pass: latent test, pooled eval features, token covariance on sub5k t0 = time.time() n_eval = len(bank.lbl["inet_eval"]) need_pool = any(t in tasks for t in ("cls", "cknna", "rank")) pooled_eval = None r2 = {(l, sd): P.R2Acc(16) for l in range(L) for sd in seeds} if W_lat else None cov = None sub_mask = torch.zeros(n_eval, dtype=torch.bool, device=bank.device) sub_mask[bank.sub5k] = True if need_pool or W_lat: for bi in _batches(n_eval): f = src.feats(bank, "inet_eval", bi, s) ti = torch.from_numpy(bi).to(bank.device) if pooled_eval is None: pooled_eval = torch.zeros(L, n_eval, f[0].shape[-1], device=bank.device) if "rank" in tasks: cov = [P.CovAcc(f[0].shape[-1], device=bank.device) for _ in range(L)] y = _clean_patches(bank.lat["inet_eval"][ti]).reshape(-1, 16) sm = sub_mask[ti] for l in range(L): pooled_eval[l, ti] = f[l].mean(1) if cov is not None and sm.any(): cov[l].add(f[l][sm].reshape(-1, f[l].shape[-1])) if W_lat: xl = f[l].reshape(-1, f[l].shape[-1]) for sd in seeds: r2[(l, sd)].add(P.RidgeStats.predict(xl, W_lat[(l, sd)][0], lref[l]), y) if W_lat: for l in range(L): res = [r2[(l, sd)].result() for sd in seeds] add(src.blocks[l], "latent_recon", "r2", [r["r2"] for r in res]) add(src.blocks[l], "latent_recon", "r2_vw", [r["r2_vw"] for r in res]) extra["timing"][f"eval_pass_s{s_lab}"] = time.time() - t0 # ---------------- rank & CKNNA (5,000 val images) if "rank" in tasks and cov is not None: for l in range(L): add(src.blocks[l], "rank", "pr_token", [cov[l].participation_ratio()]) add(src.blocks[l], "rank", "pr_pooled", [P.participation_ratio(pooled_eval[l, bank.sub5k])]) if "cknna" in tasks and teacher_sub5k is not None: for l in range(L): add(src.blocks[l], "cknna", cknna_metric, [P.cknna(pooled_eval[l, bank.sub5k], teacher_sub5k)]) # ---------------- classification (train pooled features on inet_train) if "cls" in tasks: t0 = time.time() n_tr = len(bank.lbl["inet_train"]) pooled_tr = None for bi in _batches(n_tr): f = src.feats(bank, "inet_train", bi, s) ti = torch.from_numpy(bi).to(bank.device) if pooled_tr is None: pooled_tr = torch.zeros(L, n_tr, f[0].shape[-1], device=bank.device) for l in range(L): pooled_tr[l, ti] = f[l].mean(1) extra["timing"][f"train_pass_s{s_lab}"] = time.time() - t0 t0 = time.time() fold = bank.fold["inet_train"] y = bank.lbl["inet_train"] accs = {l: [] for l in range(L)} for sd in seeds: tr, va = fold != sd, fold == sd res = P.train_logreg(pooled_tr[:, tr], y[tr], pooled_tr[:, va], y[va], pooled_eval, bank.lbl["inet_eval"], seed=sd, epochs=cls_epochs) for l in range(L): accs[l].append(res[l]["test_acc"]) extra["choices"].append(dict(s=s_lab, layer=src.blocks[l], task="imagenet_cls", seed=sd, best_lambda=res[l]["best_lambda"], val_acc=res[l]["val_acc"], val_curve=res[l]["val_curve"])) for l in range(L): add(src.blocks[l], "imagenet_cls", "top1", accs[l]) del pooled_tr extra["timing"][f"cls_probe_s{s_lab}"] = time.time() - t0 del pooled_eval torch.cuda.empty_cache() extra["timing"][f"total_s{s_lab}"] = time.time() - t_s log(f"[{src.name}] s={s_lab} done in {time.time() - t_s:.0f}s") return rows, extra def _clean_patches(lat): # [B, 4, 32, 32] -> [B, 256, 16] from .models import patchify return patchify(lat) @torch.no_grad() def teacher_sub5k_features(teacher_src: Source, bank: DataBank): idx = bank.sub5k.cpu().numpy() out = [] for i in range(0, len(idx), BATCH): f = teacher_src.feats(bank, "inet_eval", idx[i:i + BATCH], None)[0] out.append(f.mean(1)) return torch.cat(out)