LamTNguyen's picture
set5: phase 5 (random labels, MLP probes, 224 px check, SPair-71k), final analysis, conclusions, reproduce notebook
1777460 verified
Raw History Blame Contribute Delete
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))
@torch.no_grad()
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()
@torch.no_grad()
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."""
@torch.no_grad()
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()
@torch.no_grad()
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)
@torch.no_grad()
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)
@torch.no_grad()
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)
@torch.no_grad()
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
@torch.no_grad()
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:]
@torch.no_grad()
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