Download probe/runner.py from LamTNguyen/repa-representation-probing: direct link, hf CLI and curl.
- Browser
- Download file 11.2 kB
-
https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/probe/runner.py
- Command line
-
hf download hf://datasets/LamTNguyen/repa-representation-probing/probe/runner.py
-
curl -L -o runner.py https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/probe/runner.py
11.2 kB
| """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) | |
| 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) | |