LamTNguyen's picture
REPA representation probing: report, results, analysis, code
aaa6483 verified
Raw History Blame Contribute Delete
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)
@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)