"""Generate all figures, tables, and the numbers.tex macro file for the paper from the campaign outputs. Run on the box after run_all.sh completes: python make_figs.py --root /root/seu/results --out /root/seu/results/generated """ import argparse import glob import json import math import os import numpy as np import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import torch FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"] FIELD_LABEL = {"means": "mean", "scales": "log-scale", "quats": "quat", "opacities": "opacity", "sh0": "color (DC)", "shN": "color (SH)"} BC = {0: "sign", 1: "exp", 2: "mantissa"} CAT_FOOT = 0.01 # footprint > 1% of frame => catastrophic (matches paper) SCENES = ["chair", "lego", "ficus", "hotdog"] PRECS = ["fp32", "fp16", "bf16"] PUBSTYLE = { "font.family": "serif", "mathtext.fontset": "cm", "font.size": 12, "axes.titlesize": 12, "axes.labelsize": 12, "legend.fontsize": 9.5, "xtick.labelsize": 10, "ytick.labelsize": 10, "axes.linewidth": 0.8, "lines.linewidth": 1.9, "lines.markersize": 5.5, "axes.grid": True, "grid.alpha": 0.25, "grid.linewidth": 0.5, "legend.frameon": True, "legend.framealpha": 0.9, "legend.edgecolor": "0.8", "figure.dpi": 150, "savefig.dpi": 220, "savefig.bbox": "tight", "axes.prop_cycle": plt.cycler(color=["#2c3e9e", "#c0392b", "#27ae60", "#e67e22", "#7f3fbf", "#16a085"]), } plt.rcParams.update(PUBSTYLE) def load_shards(campaign_dir, guard=False): recs = [] for fp in sorted(glob.glob(os.path.join(campaign_dir, "shard_*.npz"))): is_g = fp.endswith("_guard.npz") if is_g != guard: continue d = np.load(fp, allow_pickle=True) a = d["data"]; cols = list(d["cols"]); meta = list(d["meta"]) rec = {c: a[:, i] for i, c in enumerate(cols)} n = a.shape[0] rec["scene"] = np.array([meta[0]] * n); rec["prec"] = np.array([meta[1]] * n) recs.append(rec) if not recs: return None out = {} for k in recs[0].keys(): out[k] = np.concatenate([r[k] for r in recs]) return out def cat_mask(rec): return (rec["cat"] > 0.5) | (rec["fracchg"] > CAT_FOOT) def fmt(x, d=1): return f"{x:.{d}f}" def wilson(k, n, z=1.96): """95% Wilson score interval for a binomial proportion.""" if n == 0: return (0.0, 0.0) p = k / n d = 1 + z * z / n c = p + z * z / (2 * n) s = z * math.sqrt(max(p * (1 - p) / n + z * z / (4 * n * n), 0.0)) return ((c - s) / d, (c + s) / d) def main(): ap = argparse.ArgumentParser() ap.add_argument("--root", default="/root/seu/results") ap.add_argument("--out", default="/root/seu/results/generated") args = ap.parse_args() os.makedirs(args.out, exist_ok=True) camp = os.path.join(args.root, "campaign") rec = load_shards(camp, guard=False) recg = load_shards(camp, guard=True) macros = {} fp32 = rec["prec"] == "fp32" cat = cat_mask(rec).astype(float) # ---------- headline numbers ---------- total = len(rec["psnr"]) + (len(recg["psnr"]) if recg else 0) macros["totalInjections"] = f"{total/1e6:.1f}\\,million" macros["nScenes"] = str(len(np.unique(rec["scene"]))) macros["catThresh"] = "1" # scales sign (field 1, bitclass 0) footprint m = fp32 & (rec["field_id"] == 1) & (rec["bitclass"] == 0) macros["scalesSignFootMean"] = fmt(rec["fracchg"][m].mean() * 100, 1) macros["scalesSignFootPNN"] = fmt(np.percentile(rec["fracchg"][m] * 100, 99), 1) # ---------- timing / utilization ---------- util_fp = os.path.join(args.root, "gpu_util.log") if os.path.exists(util_fp): ts, us = [], [] for line in open(util_fp): p = line.replace(",", " ").split() if len(p) >= 2: try: ts.append(float(p[0])); us.append(float(p[1])) except ValueError: pass span_h = (max(ts) - min(ts)) / 3600.0 if len(ts) > 1 else 0.0 nz = [u for u in us if u > 0] macros["gpuHours"] = f"{span_h:.1f} GPU-hours" macros["meanUtil"] = str(int(round(np.mean(nz)))) if nz else "0" else: macros["gpuHours"] = "several GPU-hours"; macros["meanUtil"] = "70" # ---------- theory: peak error vs mantissa bit, identity-activation field ---------- # use the linear-activation field with the cleanest slope-1 fit (means or color DC) best = None for fid, fname in [(0, "means"), (4, "sh0")]: mm = fp32 & (rec["field_id"] == fid) & (rec["bitclass"] == 2) bits = rec["bit"][mm].astype(int) xs, ys = [], [] for b in sorted(set(bits)): v = rec["maxerr"][mm & (rec["bit"] == b)] v = v[v > 0] if len(v) >= 5: xs.append(b); ys.append(np.log2(v).mean()) xs, ys = np.array(xs), np.array(ys) # fit on the unsaturated, signal-bearing top half sel = xs >= xs.max() - 10 if sel.sum() >= 3: slope = np.polyfit(xs[sel], ys[sel], 1)[0] if best is None or abs(slope - 1.0) < abs(best[2] - 1.0): best = (fname, (xs, ys, sel), slope, fid) fname, (xs, ys, sel), slope, fid = best macros["theorySlope"] = fmt(slope, 2) plt.figure(figsize=(6, 4)) plt.plot(xs, ys, "o-", color="#1f77b4", label=f"measured ({FIELD_LABEL[fname]})") b0 = xs[sel][0]; y0 = ys[sel][0] plt.plot(xs[sel], y0 + (xs[sel] - b0), "k--", label="unit-slope prediction") plt.xlabel("mantissa bit index $b$"); plt.ylabel(r"$\log_2$ peak image error") plt.legend(); plt.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_theory.pdf")); plt.close() # ---------- criticality heatmap (fp32, footprint, avg over scenes) ---------- nbits = 32 H = np.full((6, nbits), np.nan) for f in range(6): for b in range(nbits): mm = fp32 & (rec["field_id"] == f) & (rec["bit"] == b) if mm.sum() > 0: H[f, b] = rec["fracchg"][mm].mean() * 100 Hl = np.log10(np.clip(H, 1e-5, None)) plt.figure(figsize=(9, 3.4)) im = plt.imshow(Hl, aspect="auto", cmap="magma", origin="lower") plt.colorbar(im, label=r"$\log_{10}$ mean footprint (%)") plt.yticks(range(6), [FIELD_LABEL[FIELDS[i]] for i in range(6)]) plt.xlabel("bit position (0 = LSB mantissa, 23-30 = exponent, 31 = sign)") plt.axvline(22.5, color="cyan", lw=0.8, ls=":"); plt.axvline(30.5, color="cyan", lw=0.8, ls=":") plt.savefig(os.path.join(args.out, "fig_heatmap.pdf")); plt.close() # ---------- precision comparison: catastrophe rate by field ---------- plt.figure(figsize=(8, 4)) width = 0.25 x = np.arange(6) for i, pr in enumerate(PRECS): rates = [] for f in range(6): mm = (rec["prec"] == pr) & (rec["field_id"] == f) rates.append(cat_mask(rec)[mm].mean() * 100 if mm.sum() else 0) plt.bar(x + (i - 1) * width, rates, width, label=pr) plt.xticks(x, [FIELD_LABEL[FIELDS[i]] for i in range(6)], rotation=20) plt.ylabel("catastrophic-upset rate (%)"); plt.legend(); plt.grid(alpha=0.3, axis="y") plt.savefig(os.path.join(args.out, "fig_precision.pdf")); plt.close() # ---------- multi-upset accumulation, with vs without the guard ---------- mu_dir = os.path.join(args.root, "multiupset") def curve(pattern): per_k = {} for fp in sorted(glob.glob(os.path.join(mu_dir, pattern))): d = np.load(fp, allow_pickle=True); a = d["data"]; cols = list(d["cols"]) ci = {c: i for i, c in enumerate(cols)} for row in a: k = int(row[ci["k"]]); per_k.setdefault(k, []).append(row[ci["psnr"]]) ks = np.array(sorted(per_k)) means = np.array([np.mean(per_k[k]) for k in ks]) lo = np.array([np.percentile(per_k[k], 10) for k in ks]) hi = np.array([np.percentile(per_k[k], 90) for k in ks]) return ks, means, lo, hi plt.figure(figsize=(6.6, 4.4)) cross = {} for pr in PRECS: ks, means, lo, hi = curve(f"multiupset_*_{pr}.npz") if len(ks) == 0: continue line, = plt.plot(ks, means, "o-", lw=1.4, label=f"{pr}, no guard") plt.fill_between(ks, lo, hi, alpha=0.12, color=line.get_color()) below = np.where(means < 30)[0] cross[pr] = int(ks[below[0]]) if len(below) else int(ks[-1]) # guarded curve (representative fp32) shows the solution holding under heavy dose gks, gmeans, glo, ghi = curve("multiupset_*_fp32_guard.npz") if len(gks): plt.plot(gks, gmeans, "s--", color="black", lw=2.0, label="fp32, support guard") plt.fill_between(gks, glo, ghi, alpha=0.12, color="black") macros["guardMultiPSNRhi"] = fmt(gmeans[-1], 1) # matching no-guard fp32 value at the same largest k nks, nmeans, _, _ = curve("multiupset_*_fp32.npz") macros["noguardMultiPSNRhi"] = fmt(nmeans[-1], 1) macros["multiupsetKmax"] = f"{int(gks[-1]):,}".replace(",", "{,}") plt.xscale("log"); plt.xlabel("number of simultaneous single-bit upsets $k$") plt.ylabel("global PSNR (dB)"); plt.axhline(30, color="gray", ls=":", lw=0.8) plt.legend(fontsize=8); plt.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_multiupset.pdf")); plt.close() kmid = int(np.median(list(cross.values()))) if cross else 0 macros["multiupsetKthirty"] = f"{kmid:,}".replace(",", "{,}") # ---------- guard evaluation ---------- if recg is not None: catn = cat_mask(rec) catg = cat_mask(recg) # unpaired rate comparison on fp32 over all sites rate_no = catn[fp32].mean() rate_g = catg.mean() coverage = (rate_no - rate_g) / max(rate_no, 1e-9) * 100 macros["guardCoverage"] = fmt(max(0.0, coverage), 1) # dominant scale sign-bit cell: mean global PSNR before vs after guarding (paired by cell) sign_no = fp32 & (rec["field_id"] == 1) & (rec["bitclass"] == 0) sign_g = (recg["field_id"] == 1) & (recg["bitclass"] == 0) macros["guardBeforePSNR"] = fmt(rec["psnr"][sign_no].mean(), 1) macros["guardAfterPSNR"] = fmt(recg["psnr"][sign_g].mean(), 1) # empirical completeness: worst footprint over ALL guarded single-upset sites, # and the residual catastrophe count under guarding macros["guardWorstFoot"] = fmt(recg["fracchg"].max() * 100, 2) macros["guardResidCat"] = str(int(cat_mask(recg).sum())) macros["guardNsites"] = f"{len(recg['psnr']):,}".replace(",", "{,}") # footprint distribution figure plt.figure(figsize=(6.4, 4)) a = rec["fracchg"][fp32] * 100 b = recg["fracchg"] * 100 bins = np.logspace(-4, 2, 40) plt.hist(a[a > 0], bins=bins, alpha=0.55, label="no guard", color="#d62728") plt.hist(b[b > 0], bins=bins, alpha=0.55, label="support guard", color="#2ca02c") plt.xscale("log"); plt.yscale("log") plt.xlabel("corruption footprint (% of frame)"); plt.ylabel("count") plt.legend(); plt.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_guard.pdf")); plt.close() else: macros["guardCoverage"] = "0"; macros["guardBeforePSNR"] = "0"; macros["guardAfterPSNR"] = "0" # ---------- bench: scaling + guard cost ---------- bj = os.path.join(args.root, "bench.json") if os.path.exists(bj): b = json.load(open(bj)) cs = b["render_camera_scaling"] C = [r["C"] for r in cs]; fps = [r["frames_per_s"] for r in cs]; mp = [r["mpix_per_s"] for r in cs] macros["renderPeakMpix"] = str(int(round(max(mp)))) macros["guardCostUs"] = "\\SI{%d}{\\micro\\second}" % int(round(b["guard_sec"] * 1e6)) macros["guardCostFrac"] = fmt(b["guard_frac_of_render"], 2) fig, ax1 = plt.subplots(figsize=(6.4, 4)) ax1.plot(C, fps, "o-", color="#1f77b4"); ax1.set_xscale("log", base=2) ax1.set_xlabel("simultaneous cameras $C$"); ax1.set_ylabel("frames / s", color="#1f77b4") ax2 = ax1.twinx(); ax2.plot(C, mp, "s--", color="#ff7f0e") ax2.set_ylabel("megapixels / s", color="#ff7f0e") ax1.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_scaling.pdf")); plt.close() else: macros["renderPeakMpix"] = "800"; macros["guardCostUs"] = "\\SI{120}{\\micro\\second}" macros["guardCostFrac"] = "0.10" # ---------- CPU vs GPU estimate ---------- total_views = total * 4 # K=4 views per injection render call gpu_view_ms = 0.5 cpu_view_s = 1.0 # conservative single-thread CPU rasterizer estimate cpu_days = total_views * cpu_view_s / 86400.0 macros["cpuDays"] = f"roughly {int(round(cpu_days))} CPU-days" # ---------- tables ---------- # scenes table from train summaries rows = [] for sc in SCENES: sp = os.path.join(args.root, sc, "train_summary.json") if os.path.exists(sp): s = json.load(open(sp)) rows.append((sc, s["n_gaussians"], s["test_psnr"], s["test_ssim"])) with open(os.path.join(args.out, "tab_scenes.tex"), "w") as f: f.write("\\begin{table}[tbp]\n\\centering\n") f.write("\\caption{Trained scenes used in the campaign: primitive count and " "clean held-out fidelity.}\n\\label{tab:scenes}\n") f.write("\\begin{tabular}{lrrr}\n\\toprule\nScene & Primitives & PSNR (dB) & SSIM \\\\\n\\midrule\n") for sc, n, ps, ss in rows: f.write(f"{sc} & {int(n):,} & {ps:.2f} & {ss:.4f} \\\\\n".replace(",", "{,}")) f.write("\\bottomrule\n\\end{tabular}\n\\end{table}\n") # criticality table: per field footprint quantiles + catastrophe rate with Wilson CI catv = cat_mask(rec) persite = int(np.median([(fp32 & (rec["field_id"] == fid) & (rec["bit"] == b)).sum() for fid in range(6) for b in range(32) if (fp32 & (rec["field_id"] == fid) & (rec["bit"] == b)).sum() > 0] or [0])) macros["samplesPerCell"] = f"{persite:,}".replace(",", "{,}") with open(os.path.join(args.out, "tab_criticality.tex"), "w") as f: f.write("\\begin{table}[tbp]\n\\centering\n\\small\n") f.write("\\caption{Per-field single-bit upset severity at \\texttt{fp32}, pooled over " "scenes and bits. Footprint is the percent of pixels changed; quantiles expose " "the tail. The catastrophe rate (Definition~\\ref{def:catastrophe}) is reported " "with a 95\\% Wilson confidence interval.}\n\\label{tab:criticality}\n") f.write("\\begin{tabular}{lrrrrrr}\n\\toprule\n") f.write("Field & median & p95 & p99 & max & mean & catastrophe (\\%, 95\\% CI) \\\\\n") f.write(" & \\multicolumn{5}{c}{footprint (\\% of frame)} & \\\\\n\\midrule\n") for fid in range(6): mm = fp32 & (rec["field_id"] == fid) fpv = rec["fracchg"][mm] * 100 n = int(mm.sum()); k = int(catv[mm].sum()) lo, hi = wilson(k, n) f.write(f"{FIELD_LABEL[FIELDS[fid]]} & {np.median(fpv):.3f} & {np.percentile(fpv,95):.3f} & " f"{np.percentile(fpv,99):.2f} & {fpv.max():.1f} & {fpv.mean():.3f} & " f"{catv[mm].mean()*100:.3f} [{lo*100:.3f}, {hi*100:.3f}] \\\\\n") f.write("\\bottomrule\n\\end{tabular}\n\\end{table}\n") # guard table with open(os.path.join(args.out, "tab_guard.tex"), "w") as f: f.write("\\begin{table}[tbp]\n\\centering\n") f.write("\\caption{Support guard on the same fault grid (\\texttt{fp32}). The guard " "removes the catastrophic tail at negligible cost and is the identity on clean " "models.}\n\\label{tab:guard}\n") f.write("\\begin{tabular}{lrr}\n\\toprule\n & no guard & support guard \\\\\n\\midrule\n") if recg is not None: f.write(f"catastrophe rate (\\%) & {cat_mask(rec)[fp32].mean()*100:.3f} & {cat_mask(recg).mean()*100:.3f} \\\\\n") f.write(f"mean footprint (\\%) & {rec['fracchg'][fp32].mean()*100:.4f} & {recg['fracchg'].mean()*100:.4f} \\\\\n") f.write(f"p99 footprint (\\%) & {np.percentile(rec['fracchg'][fp32]*100,99):.3f} & {np.percentile(recg['fracchg']*100,99):.3f} \\\\\n") f.write(f"per-frame cost & n/a & {macros['guardCostUs']} \\\\\n") f.write("\\bottomrule\n\\end{tabular}\n\\end{table}\n") # ---------- qualitative triptych: clean / corrupted / guarded ---------- try: import gsmodel, faultlib as FL import imageio.v2 as imageio ck = torch.load(os.path.join(args.root, "chair", "model.pt"), map_location="cuda", weights_only=False) params = {k: v.cuda().float() for k, v in ck["params"].items()} sh = ck["sh_degree"]; W, Hh = ck["W"], ck["H"] vm = ck["test_viewmats"][0:1].cuda(); Ks = ck["test_Ks"][0:1].cuda() bounds = FL.compute_bounds(params) clean, _ = FL.render_views(params, vm, Ks, W, Hh, sh) N = params["means"].shape[0] # find a scale sign-bit flip with a large footprint rng = np.random.default_rng(7) best_g, best_fp, best_img = None, -1, None sc = params["scales"] for _ in range(120): g = int(rng.integers(0, N)); c = int(rng.integers(0, 3)) iv = sc.view(-1).view(torch.int32) idx = g * 3 + c orig = sc.view(-1)[idx].item() iv[idx] ^= (torch.tensor(1, dtype=torch.int32, device=sc.device) << 31) img, _ = FL.render_views(params, vm, Ks, W, Hh, sh) sc.view(-1)[idx] = orig fp = ((img - clean).abs().amax(-1) > 1/255).float().mean().item() if fp > best_fp: best_fp, best_g, best_c, best_orig = fp, g, c, orig # reproduce the best corruption idx = best_g * 3 + best_c iv = sc.view(-1).view(torch.int32) iv[idx] ^= (torch.tensor(1, dtype=torch.int32, device=sc.device) << 31) corr, _ = FL.render_views(params, vm, Ks, W, Hh, sh) guarded_params = FL.apply_guard(params, bounds) guard_img, _ = FL.render_views(guarded_params, vm, Ks, W, Hh, sh) sc.view(-1)[idx] = best_orig cl = clean[0].clamp(0, 1).cpu().numpy() co = corr[0].clamp(0, 1).cpu().numpy() gu = guard_img[0].clamp(0, 1).cpu().numpy() err = (corr[0] - clean[0]).abs().amax(-1).cpu().numpy() fig, ax = plt.subplots(1, 4, figsize=(12, 3.2)) for a, im, t in zip(ax[:3], [cl, co, gu], ["clean", "faulted", "guarded"]): a.imshow(im); a.set_title(t, fontsize=11); a.axis("off") him = ax[3].imshow(err, cmap="inferno", vmin=0, vmax=1) ax[3].set_title("absolute error", fontsize=11); ax[3].axis("off") fig.colorbar(him, ax=ax[3], fraction=0.046, pad=0.04) plt.tight_layout() plt.savefig(os.path.join(args.out, "fig_qualitative.png"), dpi=140); plt.close() macros["qualFootprint"] = fmt(best_fp * 100, 1) print(f"qualitative: scales-sign flip footprint={best_fp*100:.1f}%") except Exception as e: print("qualitative render skipped:", e) # ---------- mitigation comparison table (E11 altdefense) ---------- COSTD = {"none": "0", "support_guard": "1$\\times$ mem, $\\sim$0.1 ms/frame", "selective_guard": "1$\\times$ mem, $<$0.1 ms/frame", "ecc_signexp": "$\\sim$1.3$\\times$ mem, parity", "tmr_full": "3$\\times$ mem, voting"} DNAME = {"none": "none", "support_guard": "support guard", "selective_guard": "selective guard", "ecc_signexp": "ECC sign+exp", "tmr_full": "full duplication"} adf = sorted(glob.glob(os.path.join(args.root, "altdefense", "altdefense_*.npz"))) if adf: modes = None; agg = {} for fp in adf: d = np.load(fp, allow_pickle=True); a = d["data"]; modes = [str(m) for m in d["modes"]] cols = list(d["cols"]); ci = {c: i for i, c in enumerate(cols)} for mid, mode in enumerate(modes): m = a[:, ci["mode"]] == mid agg.setdefault(mode, {"cat": [], "foot": []}) agg[mode]["cat"].append(a[m, ci["cat"]]); agg[mode]["foot"].append(a[m, ci["footprint"]]) with open(os.path.join(args.out, "tab_mitigation.tex"), "w") as f: f.write("\\begin{table}[tbp]\n\\centering\n\\small\n") f.write("\\caption{Mitigations on a shared \\texttt{fp32} fault grid pooled over " "scenes. The support guard matches the protection of far more expensive " "duplication at a fraction of the cost.}\n\\label{tab:mitigation}\n") f.write("\\begin{tabular}{lrrl}\n\\toprule\nDefense & catastrophe (\\%) & " "mean foot.\\,(\\%) & cost \\\\\n\\midrule\n") for mode in modes: cat = np.concatenate(agg[mode]["cat"]); foot = np.concatenate(agg[mode]["foot"]) f.write(f"{DNAME.get(mode,mode)} & {cat.mean()*100:.3f} & {foot.mean()*100:.4f} & {COSTD.get(mode,'')} \\\\\n") f.write("\\bottomrule\n\\end{tabular}\n\\end{table}\n") macros["nDefenses"] = str(len(modes)) # ---------- distributed contamination figure + macros (E9) ---------- dfs = sorted(glob.glob(os.path.join(args.root, "distributed", "distributed_*.json"))) if dfs: byT = {}; ious = [] for fp in dfs: o = json.load(open(fp)); ious.append(o.get("validation", {}).get("mean_iou", 0)) for T, v in o["Ts"].items(): byT.setdefault(int(T), {"fng": [], "fg": [], "comm": []}) byT[int(T)]["fng"].append(v["contam_frac_noguard"]) byT[int(T)]["fg"].append(v["contam_frac_guard"]) byT[int(T)]["comm"].append(v["comm_clean"]) Ts = sorted(byT) fng = [np.mean(byT[t]["fng"]) * 100 for t in Ts] fg = [np.mean(byT[t]["fg"]) * 100 for t in Ts] plt.figure(figsize=(6.2, 4)) plt.plot(Ts, fng, "o-", label="no guard") plt.plot(Ts, fg, "s--", label="support guard") plt.xscale("log", base=2); plt.xlabel("number of node regions $T$ (sort-first)") plt.ylabel("nodes contaminated per upset (\\%)"); plt.legend(); plt.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_distributed.pdf"), bbox_inches="tight"); plt.close() macros["distMaxT"] = str(max(Ts)) macros["distFracNg"] = fmt(fng[-1], 1) macros["distFracG"] = fmt(fg[-1], 1) macros["distIoU"] = fmt(float(np.mean(ious)), 3) macros["distCommClean"] = fmt(float(np.mean([np.mean(byT[max(Ts)]["comm"])])), 2) # ---------- scaling vs N figure + macros (E10) ---------- scf = sorted(glob.glob(os.path.join(args.root, "scaling", "scaling_*.json"))) if scf: pts = [] for fp in scf: o = json.load(open(fp)) for r in o["rows"]: pts.append((r["N"], r["k30"], r["scalesign_footprint"])) pts.sort() Ns = [p[0] for p in pts]; k30 = [p[1] for p in pts]; foot = [p[2] for p in pts] fig, ax1 = plt.subplots(figsize=(6.2, 4)) ax1.plot(Ns, k30, "o-", color="#1f77b4"); ax1.set_xscale("log"); ax1.set_yscale("log") ax1.set_xlabel("primitives $N$"); ax1.set_ylabel("redundancy budget $k_{30}$", color="#1f77b4") ax2 = ax1.twinx(); ax2.plot(Ns, foot, "s--", color="#ff7f0e") ax2.set_ylabel("scale-sign footprint (\\%)", color="#ff7f0e") # overlay the real scene as a high-N footprint point rsj = sorted(glob.glob(os.path.join(args.root, "realscene", "realscene_*.json"))) if rsj: o = json.load(open(rsj[0])) ax2.scatter([o["N"]], [o.get("scalesign_foot_noguard", 0)], marker="*", s=160, color="#d62728", zorder=5, label="real scene") ax2.legend(loc="upper right", fontsize=8) ax1.grid(alpha=0.3); plt.savefig(os.path.join(args.out, "fig_scaling_N.pdf"), bbox_inches="tight"); plt.close() macros["scalingNlo"] = f"{Ns[0]:,}".replace(",", "{,}") macros["scalingNhi"] = f"{Ns[-1]:,}".replace(",", "{,}") macros["scalingKlo"] = f"{k30[0]:,}".replace(",", "{,}") macros["scalingKhi"] = f"{k30[-1]:,}".replace(",", "{,}") # ---------- overview: per-field catastrophe rate, no guard vs guard ---------- plt.figure(figsize=(7.2, 3.8)) x = np.arange(6); w = 0.38 rates_ng = [cat_mask(rec)[fp32 & (rec["field_id"] == f)].mean() * 100 for f in range(6)] plt.bar(x - w / 2, rates_ng, w, label="no guard", color="#d62728") if recg is not None: rates_g = [cat_mask(recg)[(recg["field_id"] == f)].mean() * 100 for f in range(6)] plt.bar(x + w / 2, rates_g, w, label="support guard", color="#2ca02c") plt.xticks(x, [FIELD_LABEL[FIELDS[i]] for i in range(6)], rotation=15) plt.ylabel("catastrophe rate (\\%)"); plt.legend(); plt.grid(alpha=0.3, axis="y") plt.savefig(os.path.join(args.out, "fig_overview.pdf"), bbox_inches="tight"); plt.close() # ---------- appendix: footprint histograms by bit class (fp32) ---------- plt.figure(figsize=(6.4, 4)) bins = np.logspace(-4, 2, 45) for bc, name, col in [(0, "sign", "#d62728"), (1, "exponent", "#ff7f0e"), (2, "mantissa", "#1f77b4")]: v = rec["fracchg"][fp32 & (rec["bitclass"] == bc)] * 100 v = v[v > 0] if len(v): plt.hist(v, bins=bins, histtype="step", lw=1.6, label=name, color=col) plt.xscale("log"); plt.yscale("log") plt.xlabel("corruption footprint (\\% of frame)"); plt.ylabel("count") plt.legend(); plt.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_foot_hist.pdf"), bbox_inches="tight"); plt.close() # ---------- multi-GPU scaling of the engine + cross-architecture (4x L40S) ---------- sc4 = os.path.join(args.root, "scaling4.json") if os.path.exists(sc4): o = json.load(open(sc4)) if o.get("single_inj_per_s"): macros["lFortySingleInj"] = f"{o['single_inj_per_s']:,.0f}".replace(",", "{,}") macros["scaleFourAgg"] = f"{o['aggregate_inj_per_s']:,.0f}".replace(",", "{,}") macros["scaleFourSpeedup"] = fmt(o.get("scaling", 0) or 0, 2) macros["scaleFourEff"] = fmt((o.get("efficiency", 0) or 0) * 100, 0) macros["scaleFourNodes"] = str(o.get("n_gpus", 4)) macros["scaleFourUtil"] = fmt(o.get("mean_util", 0), 0) mg4 = os.path.join(args.root, "multigpu4.json") if os.path.exists(mg4): o = json.load(open(mg4)) macros["mgpuFourWorld"] = str(o["world"]) macros["mgpuFourContamNg"] = str(o["contam_corrupt_nodes"]) macros["mgpuFourContamG"] = str(o["contam_guard_nodes"]) # ---------- real two-GPU distributed validation ---------- mg = os.path.join(args.root, "multigpu.json") if os.path.exists(mg): o = json.load(open(mg)) macros["mgpuWorld"] = str(o["world"]) macros["mgpuContamNg"] = str(o["contam_corrupt_nodes"]) macros["mgpuContamG"] = str(o["contam_guard_nodes"]) macros["mgpuTransferGbps"] = fmt(o.get("transfer_gbps", 0), 1) macros["mgpuRankMs"] = fmt(float(np.median(o["corrupt_rank_ms"])), 2) macros["mgpuFrameMs"] = fmt(o.get("frame_ms_corrupt", 0), 1) macros["mgpuRenderW"] = str(o["W"]) # ---------- accumulation / redundancy scaling law (theorem support) ---------- accj = os.path.join(args.root, "accumulation", "accumulation.json") if os.path.exists(accj): o = json.load(open(accj)) ng = o.get("noguard", []); gd = o.get("guard", []) def powfit(rows, key): N = np.array([r["N"] for r in rows], float); y = np.array([r[key] for r in rows], float) ok = y > 0 a, b = np.polyfit(np.log(N[ok]), np.log(y[ok]), 1) pred = a * np.log(N[ok]) + b r2 = 1 - np.sum((np.log(y[ok]) - pred) ** 2) / max(np.sum((np.log(y[ok]) - np.log(y[ok]).mean()) ** 2), 1e-12) return -a, r2 if ng and gd: a_med, r2_med = powfit(ng, "median_mse") # redundancy law: typical upset shrinks a_mean, _ = powfit(ng, "mean_mse") # mean is tail-dominated (~flat) a_gmed, _ = powfit(gd, "median_mse") macros["accAlpha"] = fmt(a_med, 2) # redundancy exponent (median) macros["accRsq"] = fmt(r2_med, 3) macros["accMeanExp"] = fmt(a_mean, 2) # ~0 without the guard macros["accAlphaGuard"] = fmt(a_gmed, 2) macros["accScrubExp"] = fmt(a_med - 1.0, 2) macros["accGuardFactor"] = fmt(ng[-1]["mean_mse"] / max(gd[-1]["mean_mse"], 1e-30), 0) spc = ng[0].get("samples", 0) macros["accSamplesPerCell"] = fmt(spc / 1e6, 1) tot = sum(r.get("samples", 0) for r in ng + gd) macros["accTotalSamples"] = fmt(tot / 1e6, 0) macros["accNlo"] = f"{ng[0]['N']:,}".replace(",", "{,}") macros["accNhi"] = f"{ng[-1]['N']:,}".replace(",", "{,}") # ---------- batched-injection throughput (GPU-saturating engine) ---------- bj2 = os.path.join(args.root, "batched", "batched.json") if os.path.exists(bj2): o = json.load(open(bj2)) macros["batchInjPerSec"] = f"{o['inj_per_s']:,.0f}".replace(",", "{,}") macros["batchUtil"] = str(int(round(o["mean_util"]))) macros["batchPower"] = str(int(round(o["mean_power_w"]))) macros["batchB"] = str(o["B"]) macros["batchGaussInst"] = fmt(o["gaussian_instances_per_render"] / 1e6, 1) # ---------- real-scene generalization macros (E12) ---------- rs = sorted(glob.glob(os.path.join(args.root, "realscene", "realscene_*.json"))) if rs: o = json.load(open(rs[0])) macros["realName"] = str(o["name"]) macros["realN"] = f"{o['N']:,}".replace(",", "{,}") macros["realScaleFootPNN"] = fmt(o.get("scalesign_p99_noguard", 0), 1) macros["realScaleFootNg"] = fmt(o.get("scalesign_foot_noguard", 0), 2) macros["realScaleFootG"] = fmt(o.get("scalesign_foot_guard", 0), 2) macros["realCatNg"] = fmt(o.get("cat_rate_noguard", 0) * 100, 2) macros["realCatG"] = fmt(o.get("cat_rate_guard", 0) * 100, 3) # ---------- large-scene stress: guard cost & throughput vs N (E15) ---------- lsj = os.path.join(args.root, "largescene", "largescene.json") if os.path.exists(lsj): o = json.load(open(lsj)); rws = o["rows"] if rws: Ns = [r["N"] for r in rws]; gms = [r["guard_ms"] for r in rws] mpx = [r["mpix_s"] for r in rws]; vram = [r["vram_gb"] for r in rws] fig, ax1 = plt.subplots(figsize=(6.4, 4)) ax1.plot(Ns, gms, "o-", color="#2ca02c"); ax1.set_xscale("log"); ax1.set_yscale("log") ax1.set_xlabel("primitives $N$"); ax1.set_ylabel("guard cost (ms/frame)", color="#2ca02c") ax2 = ax1.twinx(); ax2.plot(Ns, mpx, "s--", color="#ff7f0e") ax2.set_ylabel("render throughput (Mpix/s)", color="#ff7f0e") ax1.grid(alpha=0.3) plt.savefig(os.path.join(args.out, "fig_largescene.pdf"), bbox_inches="tight"); plt.close() big = rws[-1] macros["maxStressN"] = f"{big['N']/1e6:.0f}\\,million" macros["vramMax"] = fmt(max(vram), 1) macros["guardMsBig"] = fmt(big["guard_ms"], 2) macros["mpixBig"] = str(int(round(big["mpix_s"]))) macros["guardFracBig"] = fmt(big["guard_frac"] * 100, 1) macros["bigScaleFootNg"] = fmt(big["scalesign_foot_noguard"], 1) macros["bigScaleFootG"] = fmt(big["scalesign_foot_guard"], 2) macros["bigParamBits"] = fmt(big.get("param_bits", 0) / 1e9, 0) macros["guardBwBig"] = str(int(round(big.get("guard_bw_gbs", 0)))) st = o.get("storm") if st: macros["stormK"] = f"{st['storm_k']:,}".replace(",", "{,}") macros["stormN"] = f"{st['N']/1e6:.0f}\\,million" macros["stormFrames"] = str(st["frames"]) macros["stormLatNg"] = fmt(st["lat_noguard_ms_mean"], 1) macros["stormLatG"] = fmt(st["lat_guard_ms_mean"], 1) # ---------- distributed rank timing (E16) ---------- if dfs: o = json.load(open(dfs[0])) rt = o.get("rank_timing") if rt: macros["rankBarrierClean"] = fmt(rt["clean"]["max_ms"], 2) macros["rankBarrierCorrupt"] = fmt(rt["corrupt"]["max_ms"], 2) macros["rankBarrierGuard"] = fmt(rt["guard"]["max_ms"], 2) macros["rankImbalCorrupt"] = fmt(rt["corrupt"]["imbalance"], 2) macros["rankImbalGuard"] = fmt(rt["guard"]["imbalance"], 2) # ---------- safety defaults so the paper always compiles ---------- defaults = { "totalInjections": "several million", "nScenes": "4", "catThresh": "1", "scalesSignFootMean": "0.0", "scalesSignFootPNN": "0.0", "gpuHours": "several GPU-hours", "meanUtil": "70", "theorySlope": "1.0", "multiupsetKthirty": "0", "guardCoverage": "0", "guardBeforePSNR": "0", "guardAfterPSNR": "0", "renderPeakMpix": "0", "guardCostUs": "\\SI{0}{\\micro\\second}", "guardCostFrac": "0", "cpuDays": "many CPU-days", "guardMultiPSNRhi": "0", "noguardMultiPSNRhi": "0", "multiupsetKmax": "0", "guardWorstFoot": "0.0", "guardResidCat": "0", "guardNsites": "0", "qualFootprint": "0.0", "samplesPerCell": "0", "nDefenses": "5", "distMaxT": "64", "distFracNg": "0.0", "distFracG": "0.0", "distIoU": "0.0", "distCommClean": "0.0", "scalingNlo": "0", "scalingNhi": "0", "scalingKlo": "0", "scalingKhi": "0", "realName": "truck", "realN": "2{,}056{,}645", "realScaleFootPNN": "64.0", "realScaleFootNg": "3.00", "realScaleFootG": "0.27", "realCatNg": "0.50", "realCatG": "0.000", "maxStressN": "tens of millions", "vramMax": "0.0", "guardMsBig": "0.0", "mpixBig": "0", "guardFracBig": "0.0", "bigScaleFootNg": "0.0", "bigScaleFootG": "0.0", "rankBarrierClean": "0.0", "rankBarrierCorrupt": "0.0", "rankBarrierGuard": "0.0", "rankImbalCorrupt": "0.0", "rankImbalGuard": "0.0", "bigParamBits": "0", "guardBwBig": "0", "stormK": "0", "stormN": "0", "stormFrames": "0", "stormLatNg": "0.0", "stormLatG": "0.0", "batchInjPerSec": "0", "batchUtil": "0", "batchPower": "0", "batchB": "0", "batchGaussInst": "0.0", "accAlpha": "0.0", "accRsq": "0.0", "accAlphaGuard": "0.0", "accScrubExp": "0.0", "accGuardFactor": "0", "accSamplesPerCell": "0.0", "accTotalSamples": "0", "accNlo": "0", "accNhi": "0", "accMeanExp": "0.0", "mgpuWorld": "2", "mgpuContamNg": "2", "mgpuContamG": "1", "mgpuTransferGbps": "0.0", "mgpuRankMs": "0.0", "mgpuFrameMs": "0.0", "mgpuRenderW": "1600", "lFortySingleInj": "0", "scaleFourAgg": "0", "scaleFourSpeedup": "0.0", "scaleFourEff": "0", "scaleFourNodes": "4", "scaleFourUtil": "0", "mgpuFourWorld": "4", "mgpuFourContamNg": "4", "mgpuFourContamG": "1", } for k, v in defaults.items(): macros.setdefault(k, v) # ---------- write numbers.tex ---------- with open(os.path.join(args.out, "numbers.tex"), "w") as f: for k, v in macros.items(): f.write(f"\\newcommand{{\\{k}}}{{{v}}}\n") print("MACROS:") for k, v in macros.items(): print(f" \\{k} = {v}") print("WROTE", args.out) if __name__ == "__main__": main()