pei2333's picture
Add files using upload-large-folder tool
5f0e48f verified
Raw History Blame Contribute Delete
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()