Download code/route_lab.py from pei2333/Grid_CrossDomain_Compress_Delivery_20261105: direct link, hf CLI and curl.
- Browser
- Download file 16.9 kB
-
https://huggingface.co/datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/resolve/main/code/route_lab.py
- Command line
-
hf download hf://datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/code/route_lab.py
-
curl -L -o route_lab.py https://huggingface.co/datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/resolve/main/code/route_lab.py
16.9 kB
| """Routing lab: every routing rule and density-card setting from one set of forward passes per model. | |
| Sites 0..N-1 arrive in order: model 0 is the old site's model (e.g. S2), model j >= 1 an adapter trained on site j only. | |
| Every model runs once on every site's test split and the per-image detection statistics are kept, so the test mAP of | |
| any per-image routing decision is computed offline (checked: sending every image to one model reproduces that model's | |
| own val mAP). Each pass also records what the routing rules read: | |
| card style statistics (channel mean, log-std) of the first 16 LoRA-layer inputs. Per-site diagonal GMMs, fit on | |
| the site's own training split, along the site's own model (ours) or along the base model only. | |
| bn-* per-layer KL / W2 between the BN input's instance statistics and that model's BN running statistics | |
| (Miyazaki & Yamamoto, DCASE 2026 Task 7; W2 as in BN embeddings, Segu et al. 2023). | |
| cdtta base-path instance statistics of the first two LoRA-layer inputs vs per-site prototypes, Bhattacharyya. | |
| nm-* pooled base-model backbone features (layer 10) vs a per-site mean or 5 K-means centroids, cosine | |
| (LDB / S-Prompts style). | |
| deep per-site diagonal GMM on those pooled layer-10 features, along the site's own model or the base model. | |
| fused card (k=8, K=4) + deep (K=4) log-likelihoods: early-layer style and deep content in one card; fused-z scales | |
| each by the spread of its log-likelihood ratio on the first new site's val split. Base path only: the deep part | |
| also from layers 4, 6, 8 (setting .../L<layer>). | |
| Each rule routes by argmax over sites, raw or with per-site offsets set in arrival order on each new site's own val | |
| split so that a share 1-q of it stays on its own model. No site's data is used after that site's own turn. | |
| python route_lab.py --models s2.pt lt.pt --data cn.yaml br.yaml --device 0 --out ../runs/B_lab.csv | |
| """ | |
| import argparse | |
| import csv | |
| import torch | |
| from ultralytics.utils.metrics import DetMetrics | |
| from gridkd import * # noqa: F401,F403 | |
| NL = 16 # LoRA layers whose input statistics are kept; cards use the first k of them | |
| POOL = (4, 6, 8, 10) # backbone layers whose pooled output is kept; nm-*, deep and fused read layer 10, the rest is a depth ablation | |
| def lora_names(weights): | |
| for w in weights: | |
| n = [k for k, x in load_plain(w).model.named_modules() if isinstance(x, MultiLoRAConv)][:NL] | |
| if n: | |
| return n | |
| raise SystemExit("no LoRA checkpoint among --models: cannot name the card layers") | |
| def bn_params(model): # every Conv+BN of the unfused model, module order | |
| return [(n, x.bn.weight.detach().float(), x.bn.bias.detach().float(), x.bn.running_mean.float(), x.bn.running_var.float(), x.bn.eps) | |
| for n, x in model.named_modules() if isinstance(x, Conv) and hasattr(x, "bn")] | |
| def bn_dist(o, g, b, rm, rv, eps): | |
| """KL and W2 between the BN input's per-image channel Gaussians (recovered from the fused conv output) and the | |
| stored running statistics, averaged over channels; channels with |gamma| <= 1e-3 cannot be recovered and are skipped.""" | |
| f = o.float().flatten(2) | |
| sd, keep = (rv + eps).sqrt(), g.abs() > 1e-3 | |
| mx = (rm + (f.mean(-1) - b) * sd / g)[:, keep] | |
| sx = (f.std(-1, unbiased=False) * sd / g.abs())[:, keep].clamp_min(1e-6) | |
| mu, sg = rm[keep], rv[keep].sqrt().clamp_min(1e-6) | |
| kl = (torch.log(sg / sx) + (sx**2 + (mx - mu) ** 2) / (2 * sg**2) - 0.5).mean(1) | |
| return kl, ((mx - mu) ** 2 + (sx - sg) ** 2).mean(1) | |
| def collect(weights, names, data, split, device): | |
| """One val pass of one model over one split.""" | |
| y = load_plain(weights) | |
| bnp = bn_params(y.model) | |
| rec = {k: [] for k in ("style", "kl", "w2", "pools", "files", "idx")} | |
| cur, live, hs = {}, [False], [] | |
| def pre(i): | |
| def f(m, a): | |
| if live[0]: | |
| cur[("s", i)] = style_stats(a[0]).cpu() | |
| return f | |
| def post(i, p): | |
| def f(m, a, o): | |
| if live[0]: | |
| cur[("b", i)] = [t.cpu() for t in bn_dist(o, *[t.to(o.device) for t in p[1:5]], p[5])] | |
| return f | |
| def pool(L): | |
| def f(m, a, o): | |
| if live[0]: | |
| cur[("p", L)] = o.float().mean((2, 3)).cpu() | |
| return f | |
| def on_start(v): # after AutoBackend fused the model, so the hooks sit on the fused convs | |
| mods = dict(y.model.named_modules()) | |
| hs.extend(mods[n].register_forward_pre_hook(pre(i)) for i, n in enumerate(names)) | |
| hs.extend(mods[p[0]].conv.register_forward_hook(post(i, p)) for i, p in enumerate(bnp)) | |
| hs.extend(y.model.model[L].register_forward_hook(pool(L)) for L in POOL) | |
| um = v.update_metrics | |
| def update(preds, batch): # the validator skips images with neither predictions nor labels: keep the mapping | |
| k = len(v.stats["tp"]) | |
| r = um(preds, batch) | |
| for si, pr in enumerate(preds): | |
| has = len(pr) > 0 or bool((batch["batch_idx"] == si).any()) | |
| rec["idx"].append(k if has else -1) | |
| k += has | |
| assert k == len(v.stats["tp"]) | |
| rec["files"].extend(batch["im_file"]) | |
| return r | |
| v.update_metrics = update | |
| def on_batch_end(v): | |
| live[0] = False | |
| rec["style"].append([cur[("s", i)] for i in range(len(names))]) | |
| rec["kl"].append(torch.stack([cur[("b", i)][0] for i in range(len(bnp))], 1)) | |
| rec["w2"].append(torch.stack([cur[("b", i)][1] for i in range(len(bnp))], 1)) | |
| rec["pools"].append([cur[("p", L)] for L in POOL]) | |
| cur.clear() | |
| def on_val_end(v): | |
| rec["det"] = {k: [t.cpu() for t in x] for k, x in v.stats.items()} | |
| rec["map"] = (float(v.metrics.box.map50), float(v.metrics.box.map)) | |
| y.add_callback("on_val_start", on_start) | |
| y.add_callback("on_val_batch_start", lambda v: live.__setitem__(0, True)) | |
| y.add_callback("on_val_batch_end", on_batch_end) | |
| y.add_callback("on_val_end", on_val_end) | |
| y.val(data=data, split=split, device=device, workers=4, plots=False, verbose=False) | |
| for h in hs: | |
| h.remove() | |
| out = {k: torch.cat(rec[k]) for k in ("kl", "w2")} | |
| out["pools"] = {L: torch.cat([b[i] for b in rec["pools"]]) for i, L in enumerate(POOL)} | |
| out["pool"] = out["pools"][10] | |
| out["style"] = [torch.cat([b[i] for b in rec["style"]]) for i in range(len(names))] | |
| out.update(files=rec["files"], idx=rec["idx"], det=rec["det"], map=rec["map"], names=y.model.names) | |
| w = Path(weights) | |
| print(f"collected {w.parent.parent.name if w.parent.name == 'weights' else w.stem} on {Path(data).stem}:{split} n={len(rec['files'])} map={out['map'][1]:.4f}") | |
| return out | |
| def mean_ap(passes, choice): | |
| """mAP50, mAP50-95 when image x takes its detections from passes[choice[x]] (all passes cover one split).""" | |
| cols = {k: [] for k in ("tp", "conf", "pred_cls", "target_cls")} | |
| for x, j in enumerate(choice.tolist()): | |
| k = passes[j]["idx"][x] | |
| if k >= 0: | |
| for c in cols: | |
| cols[c].append(passes[j]["det"][c][k]) | |
| m = DetMetrics(names=passes[0]["names"]) | |
| m.process(*[torch.cat(cols[c]).numpy() for c in ("tp", "conf", "pred_cls", "target_cls")]) | |
| return float(m.box.map50), float(m.box.map) | |
| def kmeans(x, k=5, iters=25, seed=0): # spherical K-means on unit-norm rows | |
| c = x[torch.randperm(len(x), generator=torch.Generator().manual_seed(seed))[:k]].clone() | |
| for _ in range(iters): | |
| lab = (x @ c.T).argmax(1) | |
| c = F.normalize(torch.stack([x[lab == j].mean(0) if (lab == j).any() else c[j] for j in range(k)]), dim=1) | |
| return c | |
| def bhattacharyya(m1, s1, m2, s2): | |
| v = s1**2 + s2**2 | |
| return (0.25 * (m1 - m2) ** 2 / v + 0.5 * torch.log(v / (2 * s1 * s2))).mean(-1) | |
| def main(): | |
| p = argparse.ArgumentParser() | |
| p.add_argument("--models", nargs="+", required=True, help="site 0 (old) model, then one adapter per later site") | |
| p.add_argument("--data", nargs="+", required=True, help="one data.yaml per site, same order") | |
| p.add_argument("--q", nargs="+", type=float, default=[0.01, 0.05, 0.1]) | |
| p.add_argument("--out", required=True, help="CSV of every rule and setting; per-image scores go next to it (.pt)") | |
| p.add_argument("--device", default="0") | |
| a = p.parse_args() | |
| N = len(a.models) | |
| assert N == len(a.data) >= 2 | |
| names = lora_names(a.models[1:]) | |
| C = lambda j, d, s: collect(a.models[j], names, a.data[d], s, a.device) # noqa: E731 | |
| test = {(j, i): C(j, i, "test") for i in range(N) for j in range(N)} # model j on site i's test split | |
| own = {j: C(j, j, "train") for j in range(N)} # site j's training split along its own model | |
| base = {i: own[0] if i == 0 else C(0, i, "train") for i in range(N)} # ... and along the base model | |
| val = {(j, i): C(j, i, "val") for i in range(1, N) for j in range(i + 1)} # site i's val, models known on its arrival | |
| for i in range(N): | |
| assert all(test[(j, i)]["files"] == test[(0, i)]["files"] for j in range(N)), "image order differs between models" | |
| for j in range(N): # the offline mAP must reproduce each model's own val result | |
| got = mean_ap([test[(j, i)]], torch.zeros(len(test[(0, i)]["files"]), dtype=torch.long)) | |
| assert abs(got[1] - test[(j, i)]["map"][1]) < 1e-6, (j, i, got, test[(j, i)]["map"]) | |
| dev = "cuda" if torch.cuda.is_available() else "cpu" # after ultralytics pinned the GPU | |
| # every rule maps (model j, pass) -> per-image score of site j; higher = more likely site j | |
| def pass_of(j, key, path): # key: ("test", i) | ("val", i) | |
| jj = j if path == "own" else 0 | |
| return test[(jj, key[1])] if key[0] == "test" else val[(jj, key[1])] | |
| keys = [("test", i) for i in range(N)] + [("val", i) for i in range(1, N)] | |
| rules = {} | |
| ll = {} # card log-likelihoods per (path, site, K, feat, layer, key) | |
| for path in ("own", "base"): | |
| for j in range(N): | |
| tr = own[j] if path == "own" else base[j] | |
| for K in (1, 2, 4, 8): | |
| for feat in ("ms", "m"): | |
| for li in range(NL): | |
| x = tr["style"][li] | |
| x = x[:, : x.shape[1] // 2] if feat == "m" else x | |
| g = DiagGMM.fit(x.to(dev), K) | |
| for key in keys: | |
| if key[0] == "val" and j > key[1]: | |
| continue | |
| f = pass_of(j, key, path)["style"][li] | |
| ll[(path, j, K, feat, li, key)] = g.logp((f[:, : f.shape[1] // 2] if feat == "m" else f).to(dev)).cpu() | |
| for path in ("own", "base"): | |
| for K in (1, 2, 4, 8): | |
| for feat in ("ms", "m"): | |
| for k in (1, 2, 4, 8, 16): | |
| rules[("card", path, k, K, feat)] = lambda j, key, path=path, K=K, feat=feat, k=k: sum( | |
| ll[(path, j, K, feat, li, key)] for li in range(k)) | |
| dl = {} # deep-feature GMM log-likelihoods per (path, site, K, key) | |
| for path in ("own", "base"): | |
| for j in range(N): | |
| tr = own[j] if path == "own" else base[j] | |
| for K in (1, 4): | |
| g = DiagGMM.fit(tr["pool"].to(dev), K) | |
| for key in keys: | |
| if key[0] == "val" and j > key[1]: | |
| continue | |
| dl[(path, j, K, key)] = g.logp(pass_of(j, key, path)["pool"].to(dev)).cpu() | |
| for path in ("own", "base"): | |
| for K in (1, 4): | |
| rules[("deep", path, K)] = lambda j, key, path=path, K=K: dl[(path, j, K, key)] | |
| card, deep = rules[("card", path, 8, 4, "ms")], rules[("deep", path, 4)] | |
| rules[("fused", path)] = lambda j, key, card=card, deep=deep: card(j, key) + deep(j, key) | |
| sc = [float((f(1, ("val", 1)) - f(0, ("val", 1))).std()) for f in (card, deep)] | |
| rules[("fused-z", path)] = lambda j, key, card=card, deep=deep, sc=sc: card(j, key) / sc[0] + deep(j, key) / sc[1] | |
| for L in POOL[:-1]: # depth of the deep part, base path only (its decisions do not depend on the adapters) | |
| gs = {j: DiagGMM.fit(base[j]["pools"][L].to(dev), 4) for j in range(N)} | |
| dL = {(j, key): gs[j].logp(pass_of(j, key, "base")["pools"][L].to(dev)).cpu() for j in range(N) for key in keys | |
| if not (key[0] == "val" and j > key[1])} | |
| rules[("deep", "base", 4, f"L{L}")] = lambda j, key, dL=dL: dL[(j, key)] | |
| rules[("fused", "base", f"L{L}")] = lambda j, key, dL=dL, card=rules[("card", "base", 8, 4, "ms")]: card(j, key) + dL[(j, key)] | |
| L = test[(0, 0)]["kl"].shape[1] | |
| e, late = range(L // 3), range(L - L // 3, L) | |
| rules[("bn-kl",)] = lambda j, key: -pass_of(j, key, "own")["kl"].mean(1) | |
| rules[("bn-w2",)] = lambda j, key: -pass_of(j, key, "own")["w2"].mean(1) | |
| terms = lambda P: (P["kl"].mean(1), P["kl"][:, e].mean(1), P["w2"][:, late].mean(1)) # noqa: E731 | |
| scale = [torch.cat([terms(val[(j, 1)])[t] for j in range(2)]).mean() for t in range(3)] # first new site's val only | |
| rules[("bn-miyazaki",)] = lambda j, key: -sum(t / s for t, s in zip(terms(pass_of(j, key, "own")), scale)) | |
| ms = lambda P: [(P["style"][li][:, : P["style"][li].shape[1] // 2], P["style"][li][:, P["style"][li].shape[1] // 2 :].exp()) for li in (0, 1)] # noqa: E731 | |
| proto = {j: [(m.mean(0), s.mean(0)) for m, s in ms(base[j])] for j in range(N)} | |
| rules[("cdtta",)] = lambda j, key: -sum(bhattacharyya(m, s, *proto[j][t]) for t, (m, s) in enumerate(ms(pass_of(j, key, "base")))) | |
| unit = lambda P: F.normalize(P["pool"], dim=1) # noqa: E731 | |
| cent = {j: (F.normalize(unit(base[j]).mean(0, keepdim=True), dim=1), kmeans(unit(base[j]))) for j in range(N)} | |
| rules[("nm-mean",)] = lambda j, key: (unit(pass_of(j, key, "base")) @ cent[j][0].T).max(1).values | |
| rules[("nm-kmeans5",)] = lambda j, key: (unit(pass_of(j, key, "base")) @ cent[j][1].T).max(1).values | |
| rows, keep = [], {} | |
| for rk, fn in rules.items(): | |
| S = {key: torch.stack([fn(j, key) for j in range((key[1] + 1) if key[0] == "val" else N)], 1) for key in keys} | |
| for q in [None] + a.q: | |
| b = torch.zeros(N) | |
| if q is not None: # offsets in arrival order, each from the newest site's own val split | |
| for i in range(1, N): | |
| s = S[("val", i)] | |
| b[i] = float(((s[:, :i] + b[:i]).max(1).values - s[:, i]).quantile(1 - q)) | |
| row = {"rule": rk[0], "setting": "/".join(map(str, rk[1:])), "q": "raw" if q is None else q} | |
| for i in range(N): | |
| d = (S[("test", i)] + b).argmax(1) | |
| row[f"acc{i}"] = round(float((d == i).float().mean()), 4) | |
| row[f"map50_{i}"], row[f"map_{i}"] = (round(v, 4) for v in mean_ap([test[(j, i)] for j in range(N)], d)) | |
| if N == 2: | |
| s0, s1 = (S[("test", i)][:, 1] - S[("test", i)][:, 0] for i in range(2)) | |
| dd = s1[None, :] - s0[:, None] | |
| row["auc"] = round(float((dd > 0).float().mean() + 0.5 * (dd == 0).float().mean()), 4) | |
| rows.append(row) | |
| if rk in (("card", "own", 8, 4, "ms"), ("card", "base", 8, 4, "ms"), ("bn-miyazaki",), ("bn-kl",), ("cdtta",), ("nm-mean",), | |
| ("deep", "base", 4), ("fused", "own"), ("fused", "base"), ("fused-z", "own"), ("fused-z", "base")): | |
| keep["/".join(map(str, rk))] = {f"{k[0]}{k[1]}": v for k, v in S.items()} | |
| ref = [] # references: every image on one model, and the oracle | |
| for nm in [f"all-{j}" for j in range(N)] + ["oracle"]: | |
| row = {"rule": nm, "setting": "", "q": ""} | |
| for i in range(N): | |
| n = len(test[(0, i)]["files"]) | |
| d = torch.full((n,), i if nm == "oracle" else int(nm.split("-")[1]), dtype=torch.long) | |
| row[f"acc{i}"] = round(float((d == i).float().mean()), 4) | |
| row[f"map50_{i}"], row[f"map_{i}"] = (round(v, 4) for v in mean_ap([test[(j, i)] for j in range(N)], d)) | |
| ref.append(row) | |
| rows = ref + rows | |
| with open(a.out, "w", newline="") as fh: | |
| w = csv.DictWriter(fh, fieldnames=list(rows[-1].keys())) | |
| w.writeheader() | |
| w.writerows(rows) | |
| per_layer = {f"{k[0]}{k[1]}": torch.stack([ll[("own", 1, 4, "ms", li, k)] - ll[("own", 0, 4, "ms", li, k)] for li in range(NL)], 1) | |
| for k in keys} if N == 2 else None # card log-likelihood ratio per layer (figures) | |
| torch.save({"scores": keep, "per_layer": per_layer, "files": {i: test[(0, i)]["files"] for i in range(N)}, "names": names}, | |
| Path(a.out).with_suffix(".pt")) | |
| show = [r for r in rows if r["rule"] != "card" or r["setting"] in ("own/8/4/ms", "base/8/4/ms")] # every non-card rule | |
| print("\n".join(" | ".join(f"{v}" for v in r.values()) for r in show if r["q"] in ("raw", 0.05, ""))) | |
| if __name__ == "__main__": | |
| main() | |