Download code/make_figs.py from pei2333/Grid_CrossDomain_Compress_Delivery_20261105: direct link, hf CLI and curl.
- Browser
- Download file 17.4 kB
-
https://huggingface.co/datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/resolve/main/code/make_figs.py
- Command line
-
hf download hf://datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/code/make_figs.py
-
curl -L -o make_figs.py https://huggingface.co/datasets/pei2333/Grid_CrossDomain_Compress_Delivery_20261105/resolve/main/code/make_figs.py
17.4 kB
| """Paper figures from saved run outputs; each figure is skipped while its inputs are missing. | |
| python make_figs.py stats --device cpu # style statistics of the test images through S2 (t-SNE input), once | |
| python make_figs.py figs # writes ../figs/*.pdf from whatever exists in ../runs | |
| python make_figs.py export --device cuda:0 # runs/fig_examples.pt for paper/figs.py (journal-style figures) | |
| """ | |
| import argparse | |
| import csv | |
| from pathlib import Path | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt # noqa: E402 | |
| import torch # noqa: E402 | |
| from gridkd import * # noqa: F401,F403,E402 | |
| R, F = Path("../runs"), Path("../figs") | |
| BENCH = {"A": ("../datasets/A_weather", ("clear", "fog")), "B": ("../datasets/B_region", ("cn", "br"))} | |
| plt.rcParams.update({"font.size": 8, "axes.titlesize": 8, "figure.dpi": 200, "savefig.bbox": "tight"}) | |
| def auc(neg, pos): # P(pos > neg), ties count half | |
| d = pos[None, :] - neg[:, None] | |
| return float((d > 0).float().mean() + 0.5 * (d == 0).float().mean()) | |
| def card_names(b, k=8): | |
| return [n for n, x in load_plain(R / f"{b}_Lt/weights/best.pt").model.named_modules() if isinstance(x, MultiLoRAConv)][:k] | |
| def cmd_stats(a): | |
| from deploy_route import stats | |
| for b, (d, doms) in BENCH.items(): | |
| out = R / f"{b}_style_test.pt" | |
| if out.exists(): | |
| continue | |
| names = card_names(b) | |
| torch.save({dom: torch.cat(stats(load_plain(R / f"{b}_S2/weights/best.pt"), names, f"{d}/{dom}.yaml", "test", a.device), 1) | |
| for dom in doms}, out) | |
| print("wrote", out) | |
| def fig_layer_auc(): | |
| """Per-layer and first-k domain separability: BN statistics (all 81 layers) and density cards (first 16 LoRA inputs).""" | |
| have = [b for b in BENCH if (R / f"{b}_bnllr_on.pt").exists()] | |
| if not have: | |
| return | |
| fig, axs = plt.subplots(1, len(have), figsize=(3.4 * len(have), 2.4), squeeze=False) | |
| for ax, b in zip(axs[0], have): | |
| on, off = torch.load(R / f"{b}_bnllr_on.pt"), torch.load(R / f"{b}_bnllr_off.pt") | |
| (s1, t1, _), (s0, t0, _) = on.values(), off.values() | |
| S, T = s1[..., 0] - s0[..., 1], t1[..., 0] - t0[..., 1] # each model on its own path: target-BN vs source-BN fit | |
| L = range(1, S.shape[1] + 1) | |
| ax.plot(L, [auc(S[:, i], T[:, i]) for i in range(S.shape[1])], lw=0.8, c="C0", alpha=0.6, label="BN, single layer") | |
| ax.plot(L, [auc(S[:, :k].sum(1), T[:, :k].sum(1)) for k in L], lw=1.2, c="C0", label="BN, first k layers") | |
| lab = R / f"{b}_lab_s0.pt" | |
| if lab.exists(): | |
| p = torch.load(lab)["per_layer"] | |
| P0, P1 = p["test0"], p["test1"] | |
| K = range(1, P0.shape[1] + 1) | |
| ax.plot(K, [auc(P0[:, i], P1[:, i]) for i in range(P0.shape[1])], lw=0.8, c="C3", alpha=0.6, label="card, single layer") | |
| ax.plot(K, [auc(P0[:, :k].sum(1), P1[:, :k].sum(1)) for k in K], lw=1.2, c="C3", label="card, first k layers") | |
| for rule, se, c, lab in (("deep", "base/4", "C2", "deep part (layer-10 features)"), ("fused", "base", "k", "fused card")): | |
| v = [float(x["auc"]) for x in lab_rows(b) if x["rule"] == rule and x["setting"] == se and x["q"] == "raw"] | |
| if v: | |
| ax.axhline(v[0], c=c, lw=0.8, ls="--", label=lab) | |
| doms = BENCH[b][1] | |
| ax.set(title=f"{b}: {doms[0]} vs {doms[1]} (test)", xlabel="layer (network order)", ylabel="AUC", xscale="log", ylim=(0, 1.02)) | |
| ax.axhline(0.5, c="k", lw=0.5, ls=":") | |
| ax.grid(alpha=0.3) | |
| axs[0][0].legend(loc="lower right", fontsize=6) | |
| fig.savefig(F / "layer_auc.pdf") | |
| print("wrote layer_auc.pdf") | |
| def fig_tsne(): | |
| from sklearn.manifold import TSNE | |
| have = [b for b in BENCH if (R / f"{b}_style_test.pt").exists()] | |
| if not have: | |
| return | |
| fig, axs = plt.subplots(1, len(have), figsize=(3.0 * len(have), 2.8), squeeze=False) | |
| g = torch.Generator().manual_seed(0) | |
| for ax, b in zip(axs[0], have): | |
| st = torch.load(R / f"{b}_style_test.pt") | |
| xs = [v[torch.randperm(len(v), generator=g)[:800]] for v in st.values()] # ponytail: 800 per domain keeps t-SNE fast | |
| x = torch.cat(xs) | |
| x = ((x - x.mean(0)) / (x.std(0) + 1e-6)).numpy() | |
| e = TSNE(2, init="pca", perplexity=30, random_state=0).fit_transform(x) | |
| i = 0 | |
| for c, (dom, v) in zip(("C0", "C3"), zip(st, xs)): | |
| ax.scatter(*e[i:i + len(v)].T, s=2, c=c, alpha=0.5, lw=0, label=dom) | |
| i += len(v) | |
| ax.set(title=f"{b}: style statistics, first 8 LoRA inputs (S2)", xticks=[], yticks=[]) | |
| ax.legend(markerscale=4, fontsize=6) | |
| fig.savefig(F / "tsne_style.pdf") | |
| print("wrote tsne_style.pdf") | |
| def lab_rows(b, seed="s0"): | |
| p = R / f"{b}_lab_{seed}.csv" | |
| return list(csv.DictReader(open(p))) if p.exists() else [] | |
| def fig_llr_hist(): | |
| """Image-level log-likelihood ratio on both test sets: early-layer card (own path, 5% threshold) and fused card | |
| (base path, threshold 0).""" | |
| have = [b for b in BENCH if (R / f"{b}_lab_s0.pt").exists() and "fused/base" in torch.load(R / f"{b}_lab_s0.pt")["scores"]] | |
| if not have: | |
| return | |
| fig, axs = plt.subplots(2, len(have), figsize=(3.2 * len(have), 4.2), squeeze=False) | |
| for j, b in enumerate(have): | |
| sc = torch.load(R / f"{b}_lab_s0.pt")["scores"] | |
| for i, (key, title, q) in enumerate((("card/own/8/4/ms", "early-layer card", 0.05), ("fused/base", "fused card", None))): | |
| ax, s = axs[i][j], sc[key] | |
| r = {k: v[:, 1] - v[:, 0] for k, v in s.items()} | |
| tau = float(r["val1"].quantile(q)) if q else 0.0 | |
| sl = lambda t: torch.sign(t) * torch.log10(1 + t.abs()) # noqa: E731 signed log: the ratios span 1e0-1e4 | |
| r, tau = {k: sl(v) for k, v in r.items()}, float(sl(torch.tensor(tau))) | |
| for c, k, dom in zip(("C0", "C3"), ("test0", "test1"), BENCH[b][1]): | |
| ax.hist(r[k].numpy(), bins=80, color=c, alpha=0.55, density=True, label=dom) | |
| ax.axvline(tau, c="k", lw=0.8, label=r"$\tau$" + (" (5% of new-site val)" if q else " = 0")) | |
| ax.set(title=f"{b}: {title} (test)", yticks=[], xlabel="signed log10(1 + |LLR|), LLR = log p(new) - log p(old)" if i else None) | |
| ax.legend(fontsize=6) | |
| fig.tight_layout() | |
| fig.savefig(F / "llr_hist.pdf") | |
| print("wrote llr_hist.pdf") | |
| def fig_depth(): | |
| """Fused card with the deep part read at layer 4 / 6 / 8 / 10 of the base model: AUC against the share of the base | |
| model's MACs spent before the decision.""" | |
| have = {b: r for b in BENCH for st_ in ("s2", "s1", "s0") if (r := [x for x in lab_rows(b, st_) if x["rule"] in ("deep", "fused") and x["q"] == "raw"]) | |
| and any("/L" in x["setting"] for x in r)} | |
| if not have: | |
| return | |
| from deploy_route import macs_by_layer | |
| macs = macs_by_layer(load_plain(R / "A_S2/weights/best.pt").model.float(), 640) | |
| share = {L: sum(v for i, v in macs.items() if i <= L) / sum(macs.values()) for L in (4, 6, 8, 10)} | |
| fig, ax = plt.subplots(figsize=(3.4, 2.4)) | |
| for b, rows in have.items(): | |
| get = lambda rule, se: next(float(x["auc"]) for x in rows if x["rule"] == rule and x["setting"] == se) # noqa: E731 | |
| for rule, ls, lab in (("fused", "-", "fused card"), ("deep", ":", "deep part only")): | |
| ys = [get(rule, ("base" if rule == "fused" else "base/4") + ("" if L == 10 else f"/L{L}")) for L in (4, 6, 8, 10)] | |
| ax.plot([share[L] for L in (4, 6, 8, 10)], ys, ls=ls, marker="o", ms=3, c="C0" if b == "A" else "C3", label=f"{b}: {lab}") | |
| for L in (4, 6, 8, 10): | |
| ax.annotate(f"L{L}", (share[L], 0.5), fontsize=6, ha="center") | |
| ax.set(xlabel="share of base-model MACs before the decision", ylabel="AUC (test)", ylim=(0.45, 1.01)) | |
| ax.grid(alpha=0.3) | |
| ax.legend(fontsize=6) | |
| fig.savefig(F / "depth.pdf") | |
| print("wrote depth.pdf") | |
| def fig_card_grid(): | |
| """Early part of the fused card (base path, threshold 0): mean test mAP50-95 over both sites against layers read (k) | |
| and GMM components (K).""" | |
| have = [b for b in BENCH if lab_rows(b)] | |
| if not have: | |
| return | |
| fig, axs = plt.subplots(1, 2 * len(have), figsize=(2.3 * 2 * len(have), 2.0), squeeze=False) | |
| for j, b in enumerate(have): | |
| rows = [r for r in lab_rows(b) if r["rule"] == "card" and r["q"] == "raw"] | |
| for ax, feat in zip(axs[0][2 * j:2 * j + 2], ("ms", "m")): | |
| ks = sorted({int(r["setting"].split("/")[1]) for r in rows}) | |
| Ks = sorted({int(r["setting"].split("/")[2]) for r in rows}) | |
| M = torch.full((len(Ks), len(ks)), float("nan")) | |
| for r in rows: | |
| path, k, K, f = r["setting"].split("/") | |
| if path == "base" and f == feat: | |
| M[Ks.index(int(K)), ks.index(int(k))] = (float(r["map_0"]) + float(r["map_1"])) / 2 | |
| im = ax.imshow(M.numpy(), cmap="viridis", origin="lower") | |
| for (yy, xx), v in zip(((yy, xx) for yy in range(len(Ks)) for xx in range(len(ks))), M.flatten()): | |
| ax.text(xx, yy, f"{v:.3f}", ha="center", va="center", fontsize=5, c="w") | |
| ax.set(xticks=range(len(ks)), xticklabels=ks, yticks=range(len(Ks)), yticklabels=Ks, xlabel="k (layers)", | |
| ylabel="K (components)" if feat == "ms" else None, title=f"{b}: {'mean + log-std' if feat == 'ms' else 'mean only'}") | |
| fig.tight_layout() | |
| fig.savefig(F / "card_grid.pdf") | |
| print("wrote card_grid.pdf") | |
| def gt_boxes(img, w, h): | |
| p = Path(str(img).replace("/images/", "/labels/")).with_suffix(".txt") | |
| t = torch.tensor([[float(v) for v in ln.split()[1:5]] for ln in p.read_text().splitlines() if ln.strip()]).view(-1, 4) | |
| return torch.stack([(t[:, 0] - t[:, 2] / 2) * w, (t[:, 1] - t[:, 3] / 2) * h, (t[:, 0] + t[:, 2] / 2) * w, (t[:, 1] + t[:, 3] / 2) * h], 1) | |
| def fig_examples(): | |
| """One random test image per site (seed 0, >= 2 insulators): ground truth, old-site model, new-site model; the | |
| panel of the model the fused card picks (threshold 0) is framed.""" | |
| from PIL import Image | |
| have = [b for b in BENCH if (R / f"{b}_lab_s0.pt").exists()] | |
| if not have: | |
| return | |
| rows = [(b, i) for b in have for i in range(2)] | |
| fig, axs = plt.subplots(len(rows), 3, figsize=(6.6, 1.9 * len(rows)), squeeze=False) | |
| g = torch.Generator().manual_seed(0) | |
| for b in have: | |
| lab = torch.load(R / f"{b}_lab_s0.pt") | |
| s, tau = lab["scores"]["fused/base"], 0.0 | |
| ms = [load_plain(R / f"{b}_{w}/weights/best.pt") for w in ("S2", "Lt")] | |
| for i in range(2): | |
| files = lab["files"][i] | |
| for j in torch.randperm(len(files), generator=g).tolist(): | |
| im = Image.open(files[j]).convert("RGB") | |
| gt = gt_boxes(files[j], *im.size) | |
| if len(gt) >= 2: | |
| break | |
| llr = float(s[f"test{i}"][j, 1] - s[f"test{i}"][j, 0]) | |
| pick = int(llr > tau) | |
| ax = axs[rows.index((b, i))] | |
| pr = [m.predict(files[j], conf=0.25, device="cpu", verbose=False)[0].boxes for m in ms] | |
| for c, (bx, title) in enumerate(zip([gt] + [p.xyxy for p in pr], | |
| ["ground truth", "old-site model (S2)", "new-site model (LoRA)"])): | |
| ax[c].imshow(im) | |
| for x0, y0, x1, y1 in bx.tolist(): | |
| ax[c].add_patch(plt.Rectangle((x0, y0), x1 - x0, y1 - y0, fill=False, lw=0.8, ec="lime" if c == 0 else "yellow")) | |
| ax[c].set(xticks=[], yticks=[], title=title if c == 0 else f"{title}: {len(bx)} box" + ("" if len(bx) == 1 else "es")) | |
| if c == pick + 1: # the router's choice | |
| for sp in ax[c].spines.values(): | |
| sp.set(ec="red", lw=2.5) | |
| ax[0].set_ylabel(f"{b} {BENCH[b][1][i]}\nfused-card LLR {llr:.0f}", fontsize=7) | |
| fig.savefig(F / "examples.pdf") | |
| print("wrote examples.pdf") | |
| SHOW = {"T": "teacher (YOLO11l)", "S0": "student (YOLO11n)", "S2": "KD + projection (old site)", "FT": "full fine-tune", "J": "joint training (both sites)", | |
| "S3nt": "multi-LoRA + router", "Lt": "LoRA, source-free", "Lt_deploy_q5": "LoRA + density cards (deployed)", | |
| "S2p2": "pruned 30%", "S3p2": "pruned + multi-LoRA", "S3ntp": "pruned + multi-LoRA + router", "Ltp_deploy_q5": "pruned + LoRA + cards (deployed)", | |
| "Lt_deploy_fused": "LoRA + fused cards (deployed)", "Ltp_deploy_fused": "pruned + LoRA + fused cards (deployed)"} | |
| def fig_tradeoff(): | |
| """Mean test mAP50-95 over both sites against GFLOPs per image (mean over both test sets).""" | |
| pts = {b: {} for b in BENCH} | |
| for p in sorted(R.glob("*_eval*.csv")): | |
| if any(t in p.stem for t in ("_v1", "_nanbug", "_seed", "_cards_s")): | |
| continue | |
| for r in csv.DictReader(open(p)): | |
| b, m = r["model"].split("_", 1) | |
| if b in pts and m in SHOW: | |
| pts[b].setdefault(m, [{}, {}]) # per domain: GFLOPs (routed models vary with the routed share), mAP; later files win | |
| pts[b][m][0][r["domain"]], pts[b][m][1][r["domain"]] = float(r["gflops"]), float(r["map50_95"]) | |
| have = [b for b in BENCH if pts[b]] | |
| fig, axs = plt.subplots(1, len(have), figsize=(3.0 * len(have), 2.6), squeeze=False) | |
| style = {m: (f"C{i % 10}", "osD^v<>p"[i % 8]) for i, m in enumerate(SHOW)} | |
| for ax, b in zip(axs[0], have): | |
| for m in SHOW: | |
| if m in pts[b] and len(pts[b][m][1]) == 2: | |
| gf, v = sum(pts[b][m][0].values()) / 2, list(pts[b][m][1].values()) | |
| ax.scatter(gf, sum(v) / 2, s=16, c=style[m][0], marker=style[m][1], label=SHOW[m], ec="k", lw=0.3) | |
| ax.set(xscale="log", xlabel="GFLOPs per image", title=b) | |
| ax.grid(alpha=0.3) | |
| axs[0][0].set_ylabel("mean test mAP50-95 (both sites)") | |
| fig.subplots_adjust(wspace=0.25) | |
| h = {l: x for ax in axs[0] for x, l in zip(*ax.get_legend_handles_labels())} | |
| fig.legend(h.values(), h.keys(), loc="upper center", bbox_to_anchor=(0.5, -0.02), ncol=3, fontsize=6, frameon=False) | |
| fig.savefig(F / "tradeoff.pdf") | |
| print("wrote tradeoff.pdf") | |
| def fig_confusion(): | |
| """Three-site sequence (cn -> cnfog -> br): where each site's test images are routed, per rule (threshold 0).""" | |
| p = R / "B_lab3.pt" | |
| if not p.exists(): | |
| return | |
| sc, names = torch.load(p)["scores"], ("cn", "cnfog", "br") | |
| rules = [(k, t) for k, t in (("fused/base", "fused card"), ("card/base/8/4/ms", "early-layer style only"), ("deep/base/4", "deep part only"), | |
| ("bn-miyazaki", "BN statistics (Miyazaki)"), ("nm-mean", "nearest mean")) if k in sc] | |
| fig, axs = plt.subplots(1, len(rules), figsize=(2.0 * len(rules), 2.2), squeeze=False) | |
| for ax, (k, title) in zip(axs[0], rules): | |
| M = torch.stack([torch.bincount(sc[k][f"test{i}"].argmax(1), minlength=3).float() / len(sc[k][f"test{i}"]) for i in range(3)]) | |
| ax.imshow(M.numpy(), cmap="Blues", vmin=0, vmax=1) | |
| for i in range(3): | |
| for j in range(3): | |
| ax.text(j, i, f"{M[i, j]:.2f}", ha="center", va="center", fontsize=6, c="w" if M[i, j] > 0.6 else "k") | |
| ax.set(title=title, xticks=range(3), xticklabels=names, yticks=range(3), yticklabels=names if ax is axs[0][0] else [], xlabel="routed to") | |
| if ax is axs[0][0]: | |
| ax.set_ylabel("test images of") | |
| fig.tight_layout() | |
| fig.savefig(F / "confusion3.pdf") | |
| print("wrote confusion3.pdf") | |
| def cmd_export(a): | |
| """The example images of fig_examples (same seed and order), downscaled, with ground-truth and predicted boxes, so | |
| paper/figs.py can draw them off the server: runs/fig_examples.pt.""" | |
| import numpy as np | |
| from PIL import Image | |
| out, g = [], torch.Generator().manual_seed(0) | |
| for b in BENCH: | |
| lab = torch.load(R / f"{b}_lab_s0.pt") | |
| s = lab["scores"]["fused/base"] | |
| ms = [load_plain(R / f"{b}_{w}/weights/best.pt") for w in ("S2", "Lt")] | |
| for i in range(2): | |
| files = lab["files"][i] | |
| for j in torch.randperm(len(files), generator=g).tolist(): | |
| im = Image.open(files[j]).convert("RGB") | |
| gt = gt_boxes(files[j], *im.size) | |
| if len(gt) >= 2: | |
| break | |
| pr = [m.predict(files[j], conf=0.25, device=a.device, verbose=False)[0].boxes.xyxy.cpu() for m in ms] | |
| sc = 640 / max(im.size) | |
| small = im.resize((round(im.width * sc), round(im.height * sc))) | |
| out.append({"b": b, "i": i, "file": str(files[j]), "img": torch.from_numpy(np.asarray(small).copy()), | |
| "boxes": [x * sc for x in [gt] + pr], "llr": float(s[f"test{i}"][j, 1] - s[f"test{i}"][j, 0])}) | |
| torch.save(out, R / "fig_examples.pt") | |
| print("wrote", R / "fig_examples.pt") | |
| def cmd_figs(a): | |
| F.mkdir(exist_ok=True) | |
| for f in (fig_layer_auc, fig_tsne, fig_llr_hist, fig_depth, fig_card_grid, fig_examples, fig_tradeoff, fig_confusion): | |
| f() | |
| if __name__ == "__main__": | |
| p = argparse.ArgumentParser() | |
| p.add_argument("cmd", choices=("stats", "figs", "export")) | |
| p.add_argument("--device", default="cpu") | |
| a = p.parse_args() | |
| {"stats": cmd_stats, "figs": cmd_figs, "export": cmd_export}[a.cmd](a) | |