set5: phase 5 (random labels, MLP probes, 224 px check, SPair-71k), final analysis, conclusions, reproduce notebook
1777460 verified Download set5/code/probes5.py from LamTNguyen/repa-representation-probing: direct link, hf CLI and curl.
- Browser
- Download file 36.2 kB
-
https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/probes5.py
- Command line
-
hf download hf://datasets/LamTNguyen/repa-representation-probing/set5/code/probes5.py
-
curl -L -o probes5.py https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/probes5.py
36.2 kB
| """Set-5 probes on frozen features, built on the set 1-2 code (probes12.py = repa-probe/probe/probes.py, unchanged: | |
| reference-centred float64 ridge statistics, per-fold z-scoring, NYU depth design / metrics, logistic regression). | |
| Validation: seed j holds out fold j of the training split; that fold picks the regularisation strength (and, across | |
| layers and noise levels, the best (layer, s)). Test numbers come from the fixed test split. CIs: 95% bootstrap over | |
| test images of the seed-averaged per-image metric (2000 resamples), alongside the std over seeds. | |
| """ | |
| from __future__ import annotations | |
| import math | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| import torch | |
| import torch.nn.functional as F | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| import probes12 as P # noqa: E402 | |
| FIELDS = ["model", "method", "teacher", "steps", "layer", "s", "task", "metric", "mean", "std", "n", | |
| "size", "group", "depth_rel", "split", "ci_lo", "ci_hi"] | |
| def bootstrap_ci(per_image, n_boot=2000, seed=0): | |
| v = np.asarray(per_image, float) | |
| rng = np.random.default_rng(seed) | |
| means = v[rng.integers(0, len(v), size=(n_boot, len(v)))].mean(1) | |
| return float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5)) | |
| def depth_probe(feats_fn, data, blocks, seeds=(0, 1, 2), bs=32, device="cuda"): | |
| """feats_fn(idx) -> list over blocks of [B, 256, D]. Returns (rows, per_image, choices). | |
| rows: dicts(layer, task, metric, mean, std, n, split, ci_lo, ci_hi); per_image[metric]: [L, seeds, n_test].""" | |
| split, fold = data["split"], torch.from_numpy(data["fold"]).to(device) | |
| tr, te = np.flatnonzero(split == 0), np.flatnonzero(split == 1) | |
| A = P.upsample_matrix(device=device) | |
| L = len(blocks) | |
| stats = None | |
| for i0 in range(0, len(tr), bs): | |
| idx = tr[i0:i0 + bs] | |
| dep = torch.from_numpy(np.ascontiguousarray(data["depth"][idx])).to(device) | |
| G, b, c, n = P.depth_design(dep, A) | |
| f = feats_fn(idx) | |
| if stats is None: | |
| stats = P.RidgeStats(L, f[0].shape[-1], 1, device=device) | |
| stats.add_weighted(f, G, b, c, n, fold[torch.from_numpy(idx).to(device)]) | |
| del A | |
| fits = {(l, sd): stats.fit_seed(l, sd) for l in range(L) for sd in seeds} | |
| ref = stats.centre.ref | |
| del stats | |
| torch.cuda.empty_cache() | |
| mets = ("rmse", "delta1", "absrel", "rmse_log") | |
| per = {m: np.zeros((L, len(seeds), len(te))) for m in mets} | |
| for i0 in range(0, len(te), bs): | |
| idx = te[i0:i0 + bs] | |
| f = feats_fn(idx) | |
| dep = torch.from_numpy(np.ascontiguousarray(data["depth"][idx])).to(device) | |
| for l in range(L): | |
| for si, sd in enumerate(seeds): | |
| pred = P.RidgeStats.predict(f[l], fits[(l, sd)][0], ref[l])[..., 0] | |
| for j, d in enumerate(P.depth_metrics(pred, dep)): | |
| for m in mets: | |
| per[m][l, si, i0 + j] = d[m] | |
| rows, choices = [], [] | |
| for l in range(L): | |
| for m in mets: | |
| seed_means = per[m][l].mean(1) | |
| lo, hi = bootstrap_ci(per[m][l].mean(0)) | |
| rows.append(dict(layer=blocks[l], task="nyu_depth", metric=m, mean=float(seed_means.mean()), | |
| std=float(seed_means.std(ddof=1)), n=len(seeds), split="test", ci_lo=lo, ci_hi=hi)) | |
| val = [min(fits[(l, sd)][2]) for sd in seeds] | |
| rows.append(dict(layer=blocks[l], task="nyu_depth", metric="val_mse_logdepth", mean=float(np.mean(val)), | |
| std=float(np.std(val, ddof=1)), n=len(seeds), split="val", ci_lo="", ci_hi="")) | |
| choices.append(dict(layer=blocks[l], task="nyu_depth", alphas=[fits[(l, sd)][1] for sd in seeds], | |
| val_curves=[fits[(l, sd)][2] for sd in seeds])) | |
| return rows, per, choices | |
| def train_logreg(Xtr, ytr, Xva, yva, Xte, yte, seed, n_classes=1000, epochs=60, bs=1024, lr=1e-3, | |
| lambdas=P.LOGREG_LAMBDAS): | |
| """probes12.train_logreg (same optimiser, schedule, lambdas, z-scoring) that also returns per-image test | |
| correctness at the validation-selected lambda. X*: [L, N, D] on GPU.""" | |
| L, N, D = Xtr.shape | |
| mu, sd = Xtr.mean(1, keepdim=True), Xtr.std(1, keepdim=True) + 1e-6 | |
| Xtr_n, Xva_n, Xte_n = (Xtr - mu) / sd, (Xva - mu) / sd, (Xte - mu) / sd | |
| nl = len(lambdas) | |
| H = L * nl | |
| lam = torch.tensor(lambdas, device=Xtr.device).repeat(L) | |
| W = torch.zeros(H, D, n_classes, device=Xtr.device, requires_grad=True) | |
| b = torch.zeros(H, 1, n_classes, device=Xtr.device, requires_grad=True) | |
| opt = torch.optim.Adam([W, b], lr=lr) | |
| g = torch.Generator(device="cpu").manual_seed(seed) | |
| spe = math.ceil(N / bs) | |
| total = epochs * spe | |
| sched = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: 0.5 * (1 + math.cos(math.pi * min(s, total) / total))) | |
| for _ in range(epochs): | |
| perm = torch.randperm(N, generator=g).to(Xtr.device) | |
| for i in range(spe): | |
| idx = perm[i * bs:(i + 1) * bs] | |
| logits = torch.baddbmm(b, Xtr_n[:, idx].repeat_interleave(nl, dim=0), W) | |
| ce = F.cross_entropy(logits.reshape(-1, n_classes), ytr[idx].repeat(H), reduction="none") | |
| loss = ce.reshape(H, -1).mean(1).sum() + (lam * (W ** 2).sum((1, 2))).sum() | |
| opt.zero_grad(set_to_none=True) | |
| loss.backward() | |
| opt.step() | |
| sched.step() | |
| def correct(Xn, y): | |
| out = torch.zeros(H, Xn.shape[1], device=Xn.device) | |
| for i in range(0, Xn.shape[1], 2048): | |
| pred = torch.baddbmm(b, Xn[:, i:i + 2048].repeat_interleave(nl, dim=0), W).argmax(-1) | |
| out[:, i:i + 2048] = (pred == y[i:i + 2048][None]).float() | |
| return out.reshape(L, nl, -1).cpu().numpy() | |
| va, te = correct(Xva_n, yva).mean(-1), correct(Xte_n, yte) | |
| res = [] | |
| for l in range(L): | |
| k = int(np.argmax(va[l])) | |
| res.append(dict(best_lambda=lambdas[k], val_acc=float(va[l, k]), test_acc=float(te[l, k].mean()), | |
| test_correct=te[l, k], val_curve=[float(v) for v in va[l]])) | |
| return res | |
| def cls_probe(Xtr, ytr, fold_tr, Xte, yte, names, seeds=(0, 1, 2), epochs=60): | |
| """Pooled features X*: [L, N, D] (GPU). names: label per row of L. Returns (rows, per_image, choices).""" | |
| per = np.zeros((len(names), len(seeds), Xte.shape[1])) | |
| rows, choices, val = [], [], np.zeros((len(names), len(seeds))) | |
| for si, sd in enumerate(seeds): | |
| trm, vam = fold_tr != sd, fold_tr == sd | |
| res = train_logreg(Xtr[:, trm], ytr[trm], Xtr[:, vam], ytr[vam], Xte, yte, seed=sd, epochs=epochs) | |
| for l, r in enumerate(res): | |
| per[l, si] = r["test_correct"] | |
| val[l, si] = r["val_acc"] | |
| choices.append(dict(layer=names[l], task="imagenet_cls", seed=sd, best_lambda=r["best_lambda"], | |
| val_acc=r["val_acc"], val_curve=r["val_curve"])) | |
| for l, nm in enumerate(names): | |
| seed_means = per[l].mean(1) | |
| lo, hi = bootstrap_ci(per[l].mean(0)) | |
| rows.append(dict(layer=nm, task="imagenet_cls", metric="top1", mean=float(seed_means.mean()), | |
| std=float(seed_means.std(ddof=1)), n=len(seeds), split="test", ci_lo=lo, ci_hi=hi)) | |
| rows.append(dict(layer=nm, task="imagenet_cls", metric="val_top1", mean=float(val[l].mean()), | |
| std=float(val[l].std(ddof=1)), n=len(seeds), split="val", ci_lo="", ci_hi="")) | |
| return rows, per, choices | |
| # ============================================================================= phase 3: NYU depth + normals, ADE20K | |
| GRID = 16 # tokens per side; 16 for every phase-3/4 run, 14 for the native-224 check of patch-16 encoders (phase 5) | |
| def depth_metrics_g(pred_tok_log, depth): | |
| """probes12.depth_metrics with the token grid GRID x GRID (identical for GRID = 16).""" | |
| B = depth.shape[0] | |
| p = F.interpolate(pred_tok_log.reshape(B, 1, GRID, GRID).float(), size=depth.shape[-2:], mode="bilinear", | |
| align_corners=False)[:, 0] | |
| pd = p.exp().clamp(P.DEPTH_MIN, P.DEPTH_MAX) | |
| m = P.depth_mask(depth) | |
| out = [] | |
| for i in range(B): | |
| g, q = depth[i][m[i]], pd[i][m[i]] | |
| ratio = torch.maximum(q / g, g / q) | |
| out.append(dict(rmse=float(((q - g) ** 2).mean().sqrt()), delta1=float((ratio < 1.25).float().mean()), | |
| absrel=float(((q - g).abs() / g).mean()), rmse_log=float(((q.log() - g.log()) ** 2).mean().sqrt()))) | |
| return out | |
| class RidgeStatsK(P.RidgeStats): | |
| """RidgeStats with k pixel-level outputs (normals): per image, loss = sum_p m_p ||A_p Xb W - y_p||^2.""" | |
| def add_weighted_k(self, feats, G, B, c, n, fold): | |
| """G = A'diag(m)A [b, T, T]; B = A'(m*y) [b, T, k]; c = sum_p m_p y_p^2 [b, k]; n = sum m [b].""" | |
| for f in fold.unique().tolist(): | |
| sel = fold == f | |
| self.C[f] += c[sel].double().sum(0) | |
| self.N[f] += n[sel].double().sum() | |
| Gs, Bs = G[sel].to(P.ACC_DTYPE), B[sel].to(P.ACC_DTYPE) | |
| for li, x in enumerate(feats): | |
| xb = self._aug(self.centre(li, x[sel])).to(P.ACC_DTYPE) | |
| self.M[f, li] += torch.einsum("btd,bte->de", xb, torch.bmm(Gs, xb)).double() | |
| self.V[f, li] += torch.einsum("btd,btk->dk", xb, Bs).double() | |
| def normals_design(nrm, valid, A): | |
| """nrm [b, 480, 480, 3], valid [b, 480, 480] -> G [b,T,T], B [b,T,3], c [b,3], n [b].""" | |
| b = nrm.shape[0] | |
| m = valid.reshape(b, -1).float() | |
| y = nrm.reshape(b, -1, 3).float() | |
| G = torch.stack([(A * mi[:, None]).T @ A for mi in m]) | |
| my = m[..., None] * y | |
| return G, torch.einsum("pt,bpk->btk", A, my), (my * y).sum(1), m.sum(1) | |
| def nyu_designs(data, idx, device="cuda", bs=32): | |
| """Depth and normals ridge designs for NYU train images idx (model independent; cached by the caller).""" | |
| A = P.upsample_matrix(src=GRID, device=device) | |
| out = {k: [] for k in ("dG", "db", "dc", "dn", "nG", "nB", "nc", "nn")} | |
| for i0 in range(0, len(idx), bs): | |
| j = idx[i0:i0 + bs] | |
| dep = torch.from_numpy(np.ascontiguousarray(data["depth"][j])).to(device) | |
| for k, v in zip(("dG", "db", "dc", "dn"), P.depth_design(dep, A)): | |
| out[k].append(v.cpu()) | |
| nrm = torch.from_numpy(np.ascontiguousarray(data["normals"][j])).to(device) | |
| val = torch.from_numpy(np.ascontiguousarray(data["normals_valid"][j])).to(device) | |
| for k, v in zip(("nG", "nB", "nc", "nn"), normals_design(nrm, val, A)): | |
| out[k].append(v.cpu()) | |
| del A | |
| torch.cuda.empty_cache() | |
| return {k: torch.cat(v) for k, v in out.items()} | |
| ANG_BINS = 720 # 0.25 degree bins on [0, 180) | |
| def normals_image_stats(pred_tok, nrm, valid): | |
| """pred_tok [b, 256, 3] -> per image (n, sum_angle, n<11.25, n<22.5, n<30, histogram[720]) over valid pixels.""" | |
| b = pred_tok.shape[0] | |
| p = F.interpolate(pred_tok.reshape(b, GRID, GRID, 3).permute(0, 3, 1, 2).float(), size=nrm.shape[1:3], | |
| mode="bilinear", align_corners=False) | |
| p = F.normalize(p, dim=1) | |
| g = F.normalize(nrm.permute(0, 3, 1, 2).float(), dim=1) | |
| ang = torch.rad2deg(torch.acos((p * g).sum(1).clamp(-1, 1))) | |
| out = np.zeros((b, 5 + ANG_BINS), np.float64) | |
| for i in range(b): | |
| a = ang[i][valid[i]] | |
| out[i, 0], out[i, 1] = a.numel(), float(a.double().sum()) | |
| out[i, 2:5] = [(a < t).sum().item() for t in (11.25, 22.5, 30.0)] | |
| out[i, 5:] = torch.histc(a, bins=ANG_BINS, min=0, max=180).cpu().numpy() | |
| return out | |
| def normals_metrics_from(stats): | |
| """stats [..., N, 5+bins] summed over images (pixel-pooled, as Probe3D) -> dict of metrics.""" | |
| s = stats.sum(-2) | |
| n = s[..., 0] | |
| cum = np.cumsum(s[..., 5:], -1) | |
| half = (n / 2)[..., None] | |
| k = (cum < half).sum(-1) | |
| prev = np.take_along_axis(np.concatenate([np.zeros_like(cum[..., :1]), cum], -1), k[..., None], -1)[..., 0] | |
| inbin = np.take_along_axis(s[..., 5:], np.minimum(k, ANG_BINS - 1)[..., None], -1)[..., 0] | |
| med = (k + (half[..., 0] - prev) / np.maximum(inbin, 1)) * (180.0 / ANG_BINS) | |
| return {"mean_angle": s[..., 1] / n, "median_angle": med, "pct_11.25": 100 * s[..., 2] / n, | |
| "pct_22.5": 100 * s[..., 3] / n, "pct_30": 100 * s[..., 4] / n} | |
| def boot_weights(n, n_boot=2000, seed=0): | |
| """Multinomial resampling counts [n_boot, n] for bootstrap sums over images.""" | |
| rng = np.random.default_rng(seed) | |
| return rng.multinomial(n, np.full(n, 1.0 / n), size=n_boot).astype(np.float64) | |
| def nyu_probe(feats_fn, data, design, blocks, seeds=(0, 1, 2), bs=32, device="cuda"): | |
| """Depth (ridge, sets 1-2) and normals (ridge on unit-vector targets) from one feature pass per split. | |
| Returns rows, per-image arrays, choices.""" | |
| split, fold = data["split"], torch.from_numpy(data["fold"]).to(device) | |
| tr, te = np.flatnonzero(split == 0), np.flatnonzero(split == 1) | |
| L = len(blocks) | |
| sd_, sn_ = None, None | |
| for i0 in range(0, len(tr), bs): | |
| idx = tr[i0:i0 + bs] | |
| f = feats_fn(idx) | |
| if sd_ is None: | |
| sd_ = P.RidgeStats(L, f[0].shape[-1], 1, device=device) | |
| sn_ = RidgeStatsK(L, f[0].shape[-1], 3, device=device) | |
| sl = slice(i0, i0 + len(idx)) | |
| fo = fold[torch.from_numpy(idx).to(device)] | |
| g = {k: v[sl].to(device) for k, v in design.items()} | |
| sd_.add_weighted(f, g["dG"], g["db"], g["dc"], g["dn"], fo) | |
| sn_.add_weighted_k(f, g["nG"], g["nB"], g["nc"], g["nn"], fo) | |
| fd = {(l, s): sd_.fit_seed(l, s) for l in range(L) for s in seeds} | |
| fn = {(l, s): sn_.fit_seed(l, s) for l in range(L) for s in seeds} | |
| rd, rn = sd_.centre.ref, sn_.centre.ref | |
| del sd_, sn_ | |
| torch.cuda.empty_cache() | |
| dm = ("rmse", "delta1", "absrel", "rmse_log") | |
| dper = {m: np.zeros((L, len(seeds), len(te))) for m in dm} | |
| nst = np.zeros((L, len(seeds), len(te), 5 + ANG_BINS)) | |
| for i0 in range(0, len(te), bs): | |
| idx = te[i0:i0 + bs] | |
| f = feats_fn(idx) | |
| dep = torch.from_numpy(np.ascontiguousarray(data["depth"][idx])).to(device) | |
| nrm = torch.from_numpy(np.ascontiguousarray(data["normals"][idx])).to(device) | |
| val = torch.from_numpy(np.ascontiguousarray(data["normals_valid"][idx])).to(device) | |
| for l in range(L): | |
| for si, s in enumerate(seeds): | |
| pd = P.RidgeStats.predict(f[l], fd[(l, s)][0], rd[l])[..., 0] | |
| for j, d in enumerate(depth_metrics_g(pd, dep)): | |
| for m in dm: | |
| dper[m][l, si, i0 + j] = d[m] | |
| pn = P.RidgeStats.predict(f[l], fn[(l, s)][0], rn[l]) | |
| nst[l, si, i0:i0 + len(idx)] = normals_image_stats(pn, nrm, val) | |
| rows, choices = [], [] | |
| W = boot_weights(len(te)) | |
| for l in range(L): | |
| for m in dm: | |
| sm = dper[m][l].mean(1) | |
| lo, hi = bootstrap_ci(dper[m][l].mean(0)) | |
| rows.append(dict(layer=blocks[l], task="nyu_depth", metric=m, mean=float(sm.mean()), std=float(sm.std(ddof=1)), | |
| n=len(seeds), split="test", ci_lo=lo, ci_hi=hi)) | |
| nm = normals_metrics_from(nst[l]) # per seed | |
| bs_ = np.einsum("bn,snk->bsk", W, nst[l]) # bootstrap sums [boot, seed, k] | |
| nb = normals_metrics_from(bs_[:, :, None, :]) # [boot, seed] | |
| for m, v in nm.items(): | |
| lo, hi = np.percentile(nb[m].mean(1), [2.5, 97.5]) | |
| rows.append(dict(layer=blocks[l], task="nyu_normals", metric=m, mean=float(v.mean()), | |
| std=float(v.std(ddof=1)), n=len(seeds), split="test", ci_lo=float(lo), ci_hi=float(hi))) | |
| for task, fits in (("nyu_depth", fd), ("nyu_normals", fn)): | |
| val = [min(fits[(l, s)][2]) for s in seeds] | |
| rows.append(dict(layer=blocks[l], task=task, metric="val_mse", mean=float(np.mean(val)), | |
| std=float(np.std(val, ddof=1)), n=len(seeds), split="val", ci_lo="", ci_hi="")) | |
| choices.append(dict(layer=blocks[l], task=task, alphas=[fits[(l, s)][1] for s in seeds], | |
| val_curves=[fits[(l, s)][2] for s in seeds])) | |
| per = {**{f"depth_{m}": v for m, v in dper.items()}, "normals_stats": nst.astype(np.float32)} | |
| return rows, per, choices | |
| # ----------------------------------------------------------------------------- ADE20K linear segmentation | |
| N_SEG = 150 | |
| def token_targets(lbl): | |
| """lbl [b, 256, 256] uint8 (0 ignore) -> per-token class counts [b, T, 150] over its 16x16 pixels (T = GRID^2; | |
| for GRID < 16 the labels are first resized, nearest, to the model's GRID*16 px input).""" | |
| b = lbl.shape[0] | |
| if GRID != 16: | |
| lbl = F.interpolate(lbl[:, None].float(), size=(GRID * 16, GRID * 16), mode="nearest")[:, 0].to(torch.uint8) | |
| T = GRID * GRID | |
| t = lbl.long().reshape(b, GRID, 16, GRID, 16).permute(0, 1, 3, 2, 4).reshape(b, T, 256) | |
| cnt = torch.zeros(b, T, N_SEG + 1, device=lbl.device).scatter_add_(2, t, torch.ones_like(t, dtype=torch.float)) | |
| return cnt[..., 1:] | |
| def seg_counts(logits_tok, lbl): | |
| """logits_tok [h, b, 256, C] -> per head and image (TP, FP, FN) per class [h, b, 3, C] (pixel level, 256x256).""" | |
| h, b = logits_tok.shape[:2] | |
| up = F.interpolate(logits_tok.reshape(h * b, GRID, GRID, N_SEG).permute(0, 3, 1, 2), size=(256, 256), | |
| mode="bilinear", align_corners=False).argmax(1).reshape(h, b, -1) | |
| gt = lbl.reshape(1, b, -1).long() - 1 # -1 = ignore | |
| ok = gt >= 0 | |
| out = torch.zeros(h, b, 3, N_SEG, device=logits_tok.device) | |
| for hi in range(h): | |
| for i in range(b): | |
| g, p = gt[0, i][ok[0, i]], up[hi, i][ok[0, i]] | |
| cm = torch.bincount(g * N_SEG + p, minlength=N_SEG * N_SEG).reshape(N_SEG, N_SEG).float() | |
| tp = cm.diagonal() | |
| out[hi, i, 0], out[hi, i, 1], out[hi, i, 2] = tp, cm.sum(0) - tp, cm.sum(1) - tp | |
| return out | |
| def miou_from(c): | |
| """c [..., 3, C] (summed over images) -> mIoU over classes present in GT or prediction.""" | |
| tp, fp, fn = c[..., 0, :], c[..., 1, :], c[..., 2, :] | |
| den = tp + fp + fn | |
| iou = np.where(den > 0, tp / np.maximum(den, 1), np.nan) | |
| return np.nanmean(iou, -1) | |
| def seg_probe(feats_fn_tr, feats_fn_te, ade_tr, ade_te, blocks, seeds=(0, 1, 2), lambdas=P.LOGREG_LAMBDAS, epochs=8, | |
| bs_tok=8192, lr=1e-3, device="cuda"): | |
| """Linear per-token classifier (150 classes), soft-label cross-entropy on the 16x16 pixel class histogram of each | |
| token, trained per layer on the ADE train subset (features held in CPU RAM, centred, bf16); seed j holds out fold j | |
| of the train subset to choose the weight decay by pixel mIoU; test = ADE val (pixel mIoU on the 256 px crop).""" | |
| L, n_tr, T = len(blocks), len(ade_tr["img"]), GRID * GRID | |
| fold_img = torch.from_numpy(ade_tr["fold"]) | |
| X, ref, S1, S2, cnt, Q = None, None, None, None, torch.zeros(10, dtype=torch.float64), None | |
| with torch.no_grad(): | |
| for i0 in range(0, n_tr, 64): | |
| idx = np.arange(i0, min(n_tr, i0 + 64)) | |
| f = feats_fn_tr(idx) | |
| if X is None: | |
| D = f[0].shape[-1] | |
| X = torch.empty(L, n_tr * T, D, dtype=torch.bfloat16) | |
| ref = [x.reshape(-1, D).double().mean(0) for x in f] | |
| S1 = torch.zeros(10, L, D, dtype=torch.float64, device=device) | |
| S2 = torch.zeros_like(S1) | |
| Q = torch.empty(n_tr * T, N_SEG, dtype=torch.float16) | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_tr["lbl"][idx])).to(device) | |
| Q[i0 * T:(i0 + len(idx)) * T] = token_targets(lb).reshape(-1, N_SEG).half().cpu() | |
| fo = fold_img[idx].to(device).repeat_interleave(T) | |
| for l in range(L): | |
| xc = (f[l].reshape(-1, D).double() - ref[l]).bfloat16() | |
| X[l, i0 * T:(i0 + len(idx)) * T] = xc.cpu() | |
| xd = xc.double() | |
| S1[:, l].index_add_(0, fo, xd) | |
| S2[:, l].index_add_(0, fo, xd * xd) | |
| cnt += torch.bincount(fo.cpu(), minlength=10).double() | |
| tok_fold = fold_img.repeat_interleave(T) | |
| wt = Q.float().sum(-1) # labelled pixels per token | |
| has = wt > 0 | |
| nl, C = len(lambdas), N_SEG | |
| heads, val_miou, choices = {}, np.zeros((L, len(seeds))), [] | |
| for l in range(L): | |
| Xl = X[l].to(device) | |
| for si, sd in enumerate(seeds): | |
| trm = (tok_fold != sd) & has | |
| tri = torch.nonzero(trm).squeeze(1) | |
| n_t = cnt.clone() | |
| n_t[sd] = 0 | |
| mu = (S1[:, l].sum(0) - S1[sd, l]) / n_t.sum() | |
| var = (S2[:, l].sum(0) - S2[sd, l]) / n_t.sum() - mu ** 2 | |
| mu, sdv = mu.float(), (var.clamp_min(0).sqrt() + 1e-6).float() | |
| Wt = torch.zeros(nl, D, C, device=device, requires_grad=True) | |
| bt = torch.zeros(nl, 1, C, device=device, requires_grad=True) | |
| opt = torch.optim.Adam([Wt, bt], lr=lr) | |
| g = torch.Generator().manual_seed(sd) | |
| spe = math.ceil(len(tri) / bs_tok) | |
| total = epochs * spe | |
| sch = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: 0.5 * (1 + math.cos(math.pi * min(s, total) / total))) | |
| lam = torch.tensor(lambdas, device=device) | |
| for _ in range(epochs): | |
| perm = tri[torch.randperm(len(tri), generator=g)] | |
| for k in range(spe): | |
| b_ = perm[k * bs_tok:(k + 1) * bs_tok] | |
| xb = (Xl[b_.to(device)].float() - mu) / sdv | |
| q = Q[b_].to(device).float() | |
| w = q.sum(-1) | |
| logp = torch.log_softmax(torch.baddbmm(bt, xb.expand(nl, -1, -1), Wt), -1) | |
| ce = -(q[None] * logp).sum(-1).sum(-1) / w.sum() | |
| loss = ce.sum() + (lam * (Wt ** 2).sum((1, 2))).sum() | |
| opt.zero_grad(set_to_none=True) | |
| loss.backward() | |
| opt.step() | |
| sch.step() | |
| # validation fold: pixel mIoU per weight decay | |
| vimg = np.flatnonzero(ade_tr["fold"] == sd) | |
| vc = torch.zeros(nl, 3, C, device=device) | |
| with torch.no_grad(): | |
| for j0 in range(0, len(vimg), 16): | |
| ii = vimg[j0:j0 + 16] | |
| tok = torch.from_numpy((ii[:, None] * T + np.arange(T)).reshape(-1)) | |
| xb = (Xl[tok.to(device)].float() - mu) / sdv | |
| lg = torch.baddbmm(bt, xb.expand(nl, -1, -1), Wt).reshape(nl, len(ii), T, C) | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_tr["lbl"][ii])).to(device) | |
| vc += seg_counts(lg, lb).sum(1) | |
| vm = miou_from(vc.cpu().numpy()) | |
| kbest = int(np.nanargmax(vm)) | |
| heads[(l, si)] = (Wt.detach()[kbest].clone(), bt.detach()[kbest].clone(), mu, sdv) | |
| val_miou[l, si] = vm[kbest] | |
| choices.append(dict(layer=blocks[l], task="ade_seg", seed=sd, best_lambda=lambdas[kbest], | |
| val_miou_curve=[float(v) for v in vm])) | |
| del Xl | |
| torch.cuda.empty_cache() | |
| del X, Q | |
| # test: ADE val, per image (TP, FP, FN) per class for each layer and seed | |
| n_te = len(ade_te["img"]) | |
| per = np.zeros((L, len(seeds), n_te, 3, C), np.int32) | |
| with torch.no_grad(): | |
| for i0 in range(0, n_te, 32): | |
| idx = np.arange(i0, min(n_te, i0 + 32)) | |
| f = feats_fn_te(idx) | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_te["lbl"][idx])).to(device) | |
| for l in range(L): | |
| xc = (f[l].reshape(-1, D).double() - ref[l]).bfloat16().float() | |
| lg = [] | |
| for si in range(len(seeds)): | |
| Wb, bb, mu, sdv = heads[(l, si)] | |
| lg.append((((xc - mu) / sdv) @ Wb + bb).reshape(len(idx), T, C)) | |
| per[l, :, i0:i0 + len(idx)] = seg_counts(torch.stack(lg), lb).cpu().numpy().astype(np.int32) | |
| rows = [] | |
| Wb_ = boot_weights(n_te) | |
| for l in range(L): | |
| ms = np.array([miou_from(per[l, si].sum(0)) for si in range(len(seeds))]) | |
| bsum = np.einsum("bn,snkc->bskc", Wb_, per[l].astype(np.float64)) | |
| bm = miou_from(bsum).mean(1) | |
| lo, hi = np.percentile(bm, [2.5, 97.5]) | |
| rows.append(dict(layer=blocks[l], task="ade_seg", metric="miou", mean=float(ms.mean()), std=float(ms.std(ddof=1)), | |
| n=len(seeds), split="test", ci_lo=float(lo), ci_hi=float(hi))) | |
| rows.append(dict(layer=blocks[l], task="ade_seg", metric="val_miou", mean=float(val_miou[l].mean()), | |
| std=float(val_miou[l].std(ddof=1)), n=len(seeds), split="val", ci_lo="", ci_hi="")) | |
| return rows, {"ade_counts": per}, choices | |
| # ============================================================================= phase 5: 2-layer token-wise MLP probes | |
| MLP_HIDDEN, MLP_WDS, MLP_LR = 1024, (1e-4, 1e-2), 1e-3 | |
| class TokenMLP(torch.nn.Module): | |
| def __init__(self, d, k, hidden=MLP_HIDDEN): | |
| super().__init__() | |
| self.net = torch.nn.Sequential(torch.nn.Linear(d, hidden), torch.nn.GELU(), torch.nn.Linear(hidden, k)) | |
| def forward(self, x): | |
| return self.net(x) | |
| def _cosine(opt, total): | |
| return torch.optim.lr_scheduler.LambdaLR(opt, lambda s: 0.5 * (1 + math.cos(math.pi * min(s, total) / total))) | |
| def mlp_nyu_probe(F_all, data, task, seeds=(0, 1, 2), wds=MLP_WDS, epochs=30, bs=16, lr=MLP_LR, device="cuda"): | |
| """2-layer MLP per token on frozen features of one (block, s) cell, same objective as the ridge probe: masked | |
| pixel MSE after bilinear upsampling to 480x480 (depth: log-depth in the Eigen crop; normals: unit vectors on the | |
| valid mask). F_all [1449, T, D] on GPU. Weight decay chosen on fold `seed` of the train split (3 seeds).""" | |
| split, fold = data["split"], data["fold"] | |
| tr, te = np.flatnonzero(split == 0), np.flatnonzero(split == 1) | |
| k = 1 if task == "depth" else 3 | |
| H = W = 480 | |
| def targets(idx): | |
| if task == "depth": | |
| d = torch.from_numpy(np.ascontiguousarray(data["depth"][idx])).to(device) | |
| return torch.log(d.clamp_min(P.DEPTH_MIN))[:, None], P.depth_mask(d) | |
| n = torch.from_numpy(np.ascontiguousarray(data["normals"][idx])).to(device).float().permute(0, 3, 1, 2) | |
| return n, torch.from_numpy(np.ascontiguousarray(data["normals_valid"][idx])).to(device) | |
| def predict(mdl, X, mu, sd): | |
| b = X.shape[0] | |
| out = mdl((X - mu) / sd) # [b, T, k] | |
| return F.interpolate(out.reshape(b, GRID, GRID, k).permute(0, 3, 1, 2), size=(H, W), mode="bilinear", | |
| align_corners=False) # [b, k, H, W] | |
| def masked_mse(pred, y, m): | |
| mm = m[:, None].float() | |
| return ((pred - y) ** 2 * mm).sum() / (mm.sum() * k).clamp_min(1) | |
| rows, choices = [], [] | |
| dm = ("rmse", "delta1", "absrel", "rmse_log") | |
| dper = {m: np.zeros((len(seeds), len(te))) for m in dm} | |
| nst = np.zeros((len(seeds), len(te), 5 + ANG_BINS)) | |
| val_best = [] | |
| for si, sd in enumerate(seeds): | |
| trs, vas = tr[fold[tr] != sd], tr[fold[tr] == sd] | |
| Xtr = F_all[torch.from_numpy(trs).to(device)] | |
| mu, sdv = Xtr.mean((0, 1)), Xtr.std((0, 1)) + 1e-6 | |
| best = None | |
| for wd in wds: | |
| g = torch.Generator().manual_seed(sd) | |
| torch.manual_seed(sd) | |
| mdl = TokenMLP(F_all.shape[-1], k).to(device) | |
| opt = torch.optim.AdamW(mdl.parameters(), lr=lr, weight_decay=wd) | |
| spe = math.ceil(len(trs) / bs) | |
| sch = _cosine(opt, epochs * spe) | |
| for _ in range(epochs): | |
| perm = trs[torch.randperm(len(trs), generator=g).numpy()] | |
| for i0 in range(0, len(perm), bs): | |
| idx = perm[i0:i0 + bs] | |
| y, m = targets(idx) | |
| loss = masked_mse(predict(mdl, F_all[torch.from_numpy(idx).to(device)], mu, sdv), y, m) | |
| opt.zero_grad(set_to_none=True) | |
| loss.backward() | |
| opt.step() | |
| sch.step() | |
| with torch.no_grad(): | |
| num = den = 0.0 | |
| for i0 in range(0, len(vas), bs): | |
| idx = vas[i0:i0 + bs] | |
| y, m = targets(idx) | |
| pr = predict(mdl, F_all[torch.from_numpy(idx).to(device)], mu, sdv) | |
| mm = m[:, None].float() | |
| num += float(((pr - y) ** 2 * mm).sum()) | |
| den += float(mm.sum() * k) | |
| v = num / max(den, 1) | |
| choices.append(dict(task=f"nyu_{task}_mlp", seed=sd, wd=wd, val_mse=v)) | |
| if best is None or v < best[0]: | |
| best = (v, wd, mdl) | |
| val_best.append(best[0]) | |
| mdl = best[2] | |
| with torch.no_grad(): | |
| for i0 in range(0, len(te), bs): | |
| idx = te[i0:i0 + bs] | |
| X = F_all[torch.from_numpy(idx).to(device)] | |
| out = mdl((X - mu) / sdv) | |
| if task == "depth": | |
| dep = torch.from_numpy(np.ascontiguousarray(data["depth"][idx])).to(device) | |
| for j, d in enumerate(depth_metrics_g(out[..., 0], dep)): | |
| for mname in dm: | |
| dper[mname][si, i0 + j] = d[mname] | |
| else: | |
| nrm = torch.from_numpy(np.ascontiguousarray(data["normals"][idx])).to(device) | |
| val = torch.from_numpy(np.ascontiguousarray(data["normals_valid"][idx])).to(device) | |
| nst[si, i0:i0 + len(idx)] = normals_image_stats(out, nrm, val) | |
| if task == "depth": | |
| for mname in dm: | |
| sm = dper[mname].mean(1) | |
| lo, hi = bootstrap_ci(dper[mname].mean(0)) | |
| rows.append(dict(task="nyu_depth_mlp", metric=mname, mean=float(sm.mean()), std=float(sm.std(ddof=1)), | |
| n=len(seeds), split="test", ci_lo=lo, ci_hi=hi)) | |
| per = {f"depth_{m}": v for m, v in dper.items()} | |
| else: | |
| nm = normals_metrics_from(nst) | |
| nb = normals_metrics_from(np.einsum("bn,snk->bsk", boot_weights(len(te)), nst)[:, :, None, :]) | |
| for mname, v in nm.items(): | |
| lo, hi = np.percentile(nb[mname].mean(1), [2.5, 97.5]) | |
| rows.append(dict(task="nyu_normals_mlp", metric=mname, mean=float(v.mean()), std=float(v.std(ddof=1)), | |
| n=len(seeds), split="test", ci_lo=float(lo), ci_hi=float(hi))) | |
| per = {"normals_stats": nst.astype(np.float32)} | |
| rows.append(dict(task=f"nyu_{task}_mlp", metric="val_mse", mean=float(np.mean(val_best)), | |
| std=float(np.std(val_best, ddof=1)), n=len(seeds), split="val", ci_lo="", ci_hi="")) | |
| return rows, per, choices | |
| def mlp_seg_probe(feats_fn_tr, feats_fn_te, ade_tr, ade_te, seeds=(0, 1, 2), wds=MLP_WDS, epochs=8, bs_tok=8192, | |
| lr=MLP_LR, device="cuda"): | |
| """2-layer MLP per token for ADE20K on one (block, s) cell: same data, targets (soft-label CE on the token's pixel | |
| class histogram), folds and evaluation (pixel mIoU, 256 px crop) as seg_probe.""" | |
| n_tr, T, C = len(ade_tr["img"]), GRID * GRID, N_SEG | |
| fold_img = torch.from_numpy(ade_tr["fold"]) | |
| X, ref, S1, S2, cnt, Q = None, None, None, None, torch.zeros(10, dtype=torch.float64), None | |
| with torch.no_grad(): | |
| for i0 in range(0, n_tr, 64): | |
| idx = np.arange(i0, min(n_tr, i0 + 64)) | |
| f = feats_fn_tr(idx)[0] | |
| if X is None: | |
| D = f.shape[-1] | |
| X = torch.empty(n_tr * T, D, dtype=torch.bfloat16) | |
| ref = f.reshape(-1, D).double().mean(0) | |
| S1 = torch.zeros(10, D, dtype=torch.float64, device=device) | |
| S2 = torch.zeros_like(S1) | |
| Q = torch.empty(n_tr * T, C, dtype=torch.float16) | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_tr["lbl"][idx])).to(device) | |
| Q[i0 * T:(i0 + len(idx)) * T] = token_targets(lb).reshape(-1, C).half().cpu() | |
| fo = fold_img[idx].to(device).repeat_interleave(T) | |
| xc = (f.reshape(-1, D).double() - ref).bfloat16() | |
| X[i0 * T:(i0 + len(idx)) * T] = xc.cpu() | |
| S1.index_add_(0, fo, xc.double()) | |
| S2.index_add_(0, fo, xc.double() ** 2) | |
| cnt += torch.bincount(fo.cpu(), minlength=10).double() | |
| tok_fold = fold_img.repeat_interleave(T) | |
| has = Q.float().sum(-1) > 0 | |
| Xg = X.to(device) | |
| models, val_miou, choices = {}, [], [] | |
| for si, sd in enumerate(seeds): | |
| tri = torch.nonzero((tok_fold != sd) & has).squeeze(1) | |
| n_t = cnt.clone() | |
| n_t[sd] = 0 | |
| mu = ((S1.sum(0) - S1[sd]) / n_t.sum()).float() | |
| sdv = (((S2.sum(0) - S2[sd]) / n_t.sum() - ((S1.sum(0) - S1[sd]) / n_t.sum()) ** 2).clamp_min(0).sqrt() | |
| + 1e-6).float() | |
| vimg = np.flatnonzero(ade_tr["fold"] == sd) | |
| best = None | |
| for wd in wds: | |
| g = torch.Generator().manual_seed(sd) | |
| torch.manual_seed(sd) | |
| mdl = TokenMLP(D, C).to(device) | |
| opt = torch.optim.AdamW(mdl.parameters(), lr=lr, weight_decay=wd) | |
| spe = math.ceil(len(tri) / bs_tok) | |
| sch = _cosine(opt, epochs * spe) | |
| for _ in range(epochs): | |
| perm = tri[torch.randperm(len(tri), generator=g)] | |
| for kk in range(spe): | |
| b_ = perm[kk * bs_tok:(kk + 1) * bs_tok] | |
| q = Q[b_].to(device).float() | |
| logp = torch.log_softmax(mdl((Xg[b_.to(device)].float() - mu) / sdv), -1) | |
| loss = -(q * logp).sum() / q.sum() | |
| opt.zero_grad(set_to_none=True) | |
| loss.backward() | |
| opt.step() | |
| sch.step() | |
| vc = torch.zeros(1, 3, C, device=device) | |
| with torch.no_grad(): | |
| for j0 in range(0, len(vimg), 16): | |
| ii = vimg[j0:j0 + 16] | |
| tok = torch.from_numpy((ii[:, None] * T + np.arange(T)).reshape(-1)).to(device) | |
| lg = mdl((Xg[tok].float() - mu) / sdv).reshape(1, len(ii), T, C) | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_tr["lbl"][ii])).to(device) | |
| vc += seg_counts(lg, lb).sum(1) | |
| vm = float(miou_from(vc.cpu().numpy())[0]) | |
| choices.append(dict(task="ade_seg_mlp", seed=sd, wd=wd, val_miou=vm)) | |
| if best is None or vm > best[0]: | |
| best = (vm, wd, mdl) | |
| val_miou.append(best[0]) | |
| models[si] = (best[2], mu, sdv) | |
| del Xg, X, Q | |
| torch.cuda.empty_cache() | |
| n_te = len(ade_te["img"]) | |
| per = np.zeros((len(seeds), n_te, 3, C), np.int32) | |
| with torch.no_grad(): | |
| for i0 in range(0, n_te, 32): | |
| idx = np.arange(i0, min(n_te, i0 + 32)) | |
| f = feats_fn_te(idx)[0] | |
| xc = (f.reshape(-1, D).double() - ref).bfloat16().float() | |
| lb = torch.from_numpy(np.ascontiguousarray(ade_te["lbl"][idx])).to(device) | |
| lg = torch.stack([mdl((xc - mu) / sdv).reshape(len(idx), T, C) for mdl, mu, sdv in | |
| (models[si] for si in range(len(seeds)))]) | |
| per[:, i0:i0 + len(idx)] = seg_counts(lg, lb).cpu().numpy().astype(np.int32) | |
| ms = np.array([miou_from(per[si].sum(0)) for si in range(len(seeds))]) | |
| bm = miou_from(np.einsum("bn,snkc->bskc", boot_weights(n_te), per.astype(np.float64))).mean(1) | |
| lo, hi = np.percentile(bm, [2.5, 97.5]) | |
| rows = [dict(task="ade_seg_mlp", metric="miou", mean=float(ms.mean()), std=float(ms.std(ddof=1)), n=len(seeds), | |
| split="test", ci_lo=float(lo), ci_hi=float(hi)), | |
| dict(task="ade_seg_mlp", metric="val_miou", mean=float(np.mean(val_miou)), std=float(np.std(val_miou, ddof=1)), | |
| n=len(seeds), split="val", ci_lo="", ci_hi="")] | |
| return rows, {"ade_counts": per}, choices | |