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