Upload folder using huggingface_hub

code/campaign_batched.py

@@ -0,0 +1,115 @@
+"""Batched parallel fault injection: render B independently-corrupted variants of
+the scene in a single rasterizer call, so the device is saturated rather than
+latency-bound. The batch buffer is allocated once; each step flips one bit in one
+parameter of each batch element (vectorized, no Python loop), renders all B at
+once, scores them against the clean image, then restores. Reports sustained
+injection throughput and GPU utilisation.
+"""
+import argparse
+import json
+import os
+import subprocess
+import threading
+import time
+
+import numpy as np
+import torch
+from gsplat import rasterization
+
+FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]
+FIELD_ID = {f: i for i, f in enumerate(FIELDS)}
+
+
+def util_sampler(stop, out):
+    while not stop.is_set():
+        try:
+            r = subprocess.run(["nvidia-smi", "--query-gpu=utilization.gpu,power.draw",
+                                "--format=csv,noheader,nounits"], capture_output=True, text=True, timeout=5)
+            u, p = r.stdout.strip().split("\n")[0].split(",")
+            out.append((float(u), float(p)))
+        except Exception:
+            pass
+        stop.wait(1.0)
+
+
+def render_batch(wb, sh, vm, K, W, H):
+    colors = torch.cat([wb["sh0"], wb["shN"]], dim=2)
+    renders, alphas, _ = rasterization(
+        wb["means"], wb["quats"], torch.exp(wb["scales"]), torch.sigmoid(wb["opacities"]),
+        colors, vm, K, W, H, sh_degree=sh, packed=True, rasterize_mode="classic")
+    return (renders + (1.0 - alphas)).clamp(0, 1)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="/root/seu/results/chair/model.pt")
+    ap.add_argument("--out", default="/root/seu/results/batched")
+    ap.add_argument("--B", type=int, default=32)
+    ap.add_argument("--minutes", type=float, default=8.0)
+    ap.add_argument("--seed", type=int, default=0)
+    args = ap.parse_args()
+    os.makedirs(args.out, exist_ok=True)
+    dev = "cuda"
+    ck = torch.load(args.model, map_location=dev, weights_only=False)
+    params = {k: v.to(dev).float() for k, v in ck["params"].items()}
+    sh, W, H = ck["sh_degree"], ck["W"], ck["H"]
+    N = params["means"].shape[0]
+    B = args.B
+    vmb = ck["test_viewmats"][:1].to(dev)[None].repeat(B, 1, 1, 1).contiguous()
+    Kb = ck["test_Ks"][:1].to(dev)[None].repeat(B, 1, 1, 1).contiguous()
+    comps = {f: params[f].reshape(N, -1).shape[1] for f in FIELDS}
+
+    # allocate the batch buffer once: B identical clean copies
+    wb = {k: params[k][None].repeat(B, *([1] * params[k].dim())).contiguous() for k in FIELDS}
+    clean = render_batch({k: params[k][None] for k in FIELDS}, sh, vmb[:1], Kb[:1], W, H)[0, 0]
+    rows_b = torch.arange(B, device=dev)
+    g = torch.Generator(device=dev); g.manual_seed(args.seed)
+
+    def step():
+        fi = int(torch.randint(0, 6, (1,), generator=g, device=dev).item())
+        field = FIELDS[fi]; Cf = comps[field]
+        fb = wb[field].reshape(B, N * Cf)                 # view of the batch buffer
+        iv = fb.view(torch.int32)
+        idx = torch.randint(0, N * Cf, (B,), generator=g, device=dev)  # int64 index
+        bit = torch.randint(0, 32, (B,), generator=g, device=dev, dtype=torch.int32)
+        clean_int = iv[rows_b, idx].clone()
+        mask = (torch.ones(B, dtype=torch.int32, device=dev) << bit)
+        iv[rows_b, idx] = clean_int ^ mask                # vectorized flip
+        img = render_batch(wb, sh, vmb, Kb, W, H)         # [B,1,H,W,3]
+        d = (img[:, 0] - clean).abs()
+        fr = (d.amax(-1) > 1 / 255).float().mean(dim=(1, 2))
+        finite = torch.isfinite(img).all(dim=(1, 2, 3, 4))
+        iv[rows_b, idx] = clean_int                       # vectorized restore
+        bitc = torch.where(bit == 31, 0, torch.where(bit >= 23, 1, 2))
+        out = torch.stack([torch.full((B,), fi, device=dev), bit.float(), bitc.float(),
+                           fr, ((~finite) | (fr > 0.01)).float()], dim=1)
+        return out.cpu().numpy()
+
+    for _ in range(3):
+        step()
+    torch.cuda.synchronize()
+
+    stop = threading.Event(); samples = []
+    th = threading.Thread(target=util_sampler, args=(stop, samples)); th.start()
+    t0 = time.time(); n_inj = 0; allrows = []
+    while time.time() - t0 < args.minutes * 60:
+        allrows.append(step()); n_inj += B
+    torch.cuda.synchronize(); dt = time.time() - t0
+    stop.set(); th.join()
+    util = np.array([s[0] for s in samples]) if samples else np.array([0.0])
+    powr = np.array([s[1] for s in samples]) if samples else np.array([0.0])
+
+    arr = np.concatenate(allrows, 0)
+    np.savez_compressed(os.path.join(args.out, "batched_rows.npz"), data=arr,
+                        cols=np.array(["field_id", "bit", "bitclass", "fracchg", "cat"]))
+    res = {"N": int(N), "B": B, "W": W, "H": H, "minutes": args.minutes,
+           "injections": int(n_inj), "seconds": dt, "inj_per_s": n_inj / dt,
+           "batches_per_s": (n_inj / B) / dt, "gaussian_instances_per_render": int(B * N),
+           "mean_util": float(util.mean()), "p50_util": float(np.median(util)),
+           "max_util": float(util.max()), "mean_power_w": float(powr.mean())}
+    json.dump(res, open(os.path.join(args.out, "batched.json"), "w"), indent=2)
+    print("BATCHED_RESULT", json.dumps(res), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/distributed_multigpu.py

@@ -0,0 +1,130 @@
+"""Real two-GPU distributed sort-first rendering with the node-local support guard.
+
+Each of the two physical GPUs is a rendering node (rank) that renders one screen
+half of the same model and contributes it to the composite over the real PCIe
+interconnect (NCCL all-gather). We measure, on actual hardware rather than by
+emulation: per-rank render time and load imbalance, the inter-GPU transfer time and
+bandwidth for compositing, how many nodes a single scale-sign upset contaminates,
+and how the node-local guard (applied independently on each GPU's replica before it
+renders) contains that contamination. This validates the distributed claims against
+a genuine multi-GPU interconnect.
+"""
+import argparse
+import json
+import os
+import time
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+
+import faultlib as F
+
+
+def render_half(params, rank, world, vm, Kfull, W, H, sh):
+    Wh = W // world
+    K = Kfull.clone()
+    K[0, 0, 2] = K[0, 0, 2] - rank * Wh   # shift principal point to this node's column band
+    img, _ = F.render_views(params, vm, K, Wh, H, sh)
+    return img[0].contiguous()            # [H, Wh, 3]
+
+
+def worker(rank, world, args):
+    os.environ.setdefault("MASTER_ADDR", "127.0.0.1")
+    os.environ.setdefault("MASTER_PORT", "29517")
+    dist.init_process_group("nccl", rank=rank, world_size=world)
+    torch.cuda.set_device(rank)
+    dev = f"cuda:{rank}"
+    ck = torch.load(args.model, map_location=dev, weights_only=False)
+    params = {k: v.to(dev).float() for k, v in ck["params"].items()}
+    sh, W0, H0 = ck["sh_degree"], ck["W"], ck["H"]
+    vm = ck["test_viewmats"][:1].to(dev)
+    K = ck["test_Ks"][:1].to(dev).clone()
+    # render at a larger frame (supersample) so the inter-GPU transfer is bandwidth-
+    # rather than latency-bound; scale the intrinsics accordingly
+    W = H = args.render_W
+    s = W / W0
+    K[0, :2, :] = K[0, :2, :] * s
+    Wh = W // world
+    bounds = F.compute_bounds(params)
+    stored, work = F.quantize_params(params, "fp32")
+    N = params["means"].shape[0]
+
+    # rank 0 finds a frame-spanning scale-sign upset and broadcasts the site
+    site = torch.zeros(1, dtype=torch.long, device=dev)
+    if rank == 0:
+        cfull, _ = F.render_views(work, vm, K, W, H, sh)
+        rng = np.random.default_rng(0); best = (-1.0, 0)
+        for _ in range(80):
+            gi = int(rng.integers(0, N)); flat = gi * 3
+            cv, _ = F.flip_one(stored["scales"], work["scales"], flat, 31, "fp32")
+            img, _ = F.render_views(work, vm, K, W, H, sh)
+            F.restore_one(work["scales"], flat, cv)
+            fp = ((img[0] - cfull[0]).abs().amax(-1) > 1 / 255).float().mean().item()
+            if fp > best[0]:
+                best = (fp, flat)
+        site[0] = best[1]
+    dist.broadcast(site, src=0)
+    flat = int(site[0].item())
+
+    def render_gather(p, reps=25):
+        render_half(p, rank, world, vm, K, W, H, sh)        # warmup (untimed)
+        dist.barrier()
+        rts, gts = [], []
+        full = None
+        for _ in range(reps):
+            torch.cuda.synchronize(); t = time.time()
+            half = render_half(p, rank, world, vm, K, W, H, sh)
+            torch.cuda.synchronize(); rts.append(time.time() - t)
+            halves = [torch.zeros_like(half) for _ in range(world)]
+            torch.cuda.synchronize(); t2 = time.time()
+            dist.all_gather(halves, half)                   # real inter-GPU transfer
+            torch.cuda.synchronize(); gts.append(time.time() - t2)
+            full = torch.cat(halves, dim=1)
+        rt = float(np.median(rts)); gt = float(np.median(gts))
+        rtimes = [torch.zeros(1, device=dev) for _ in range(world)]
+        dist.all_gather(rtimes, torch.tensor([rt], device=dev))
+        return full, [float(x.item()) for x in rtimes], gt, half.numel() * 4 * (world - 1)
+
+    clean_full, ct, cg, _ = render_gather(work)
+    cv, _ = F.flip_one(stored["scales"], work["scales"], flat, 31, "fp32")
+    corr_full, xt, xg, xb = render_gather(work)
+    gw = F.apply_guard(work, bounds)
+    guard_full, gt, gg, _ = render_gather(gw)
+    F.restore_one(work["scales"], flat, cv)
+
+    if rank == 0:
+        def nodes_changed(full):
+            d = (full - clean_full).abs().amax(-1) > (1 / 255)
+            return sum(int(bool(d[:, r * Wh:(r + 1) * Wh].any())) for r in range(world))
+        res = {"world": world, "W": W, "H": H, "Wh": Wh, "N": int(N),
+               "clean_rank_ms": [t * 1e3 for t in ct],
+               "corrupt_rank_ms": [t * 1e3 for t in xt],
+               "guard_rank_ms": [t * 1e3 for t in gt],
+               "transfer_ms": xg * 1e3, "transfer_bytes": int(xb),
+               "transfer_gbps": (xb / 1e9) / xg if xg > 0 else 0,
+               "imbalance_corrupt": max(xt) / (sum(xt) / world),
+               "imbalance_guard": max(gt) / (sum(gt) / world),
+               "contam_corrupt_nodes": nodes_changed(corr_full),
+               "contam_guard_nodes": nodes_changed(guard_full),
+               "frame_ms_clean": max(ct) * 1e3 + cg * 1e3,
+               "frame_ms_corrupt": max(xt) * 1e3 + xg * 1e3,
+               "frame_ms_guard": max(gt) * 1e3 + gg * 1e3}
+        json.dump(res, open(args.out, "w"), indent=2)
+        print("MULTIGPU_RESULT", json.dumps(res), flush=True)
+    dist.barrier(); dist.destroy_process_group()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="/root/seu/results/chair/model.pt")
+    ap.add_argument("--out", default="/root/seu/results/multigpu.json")
+    ap.add_argument("--world", type=int, default=2)
+    ap.add_argument("--render_W", type=int, default=1600)
+    args = ap.parse_args()
+    mp.spawn(worker, args=(args.world, args), nprocs=args.world, join=True)
+
+
+if __name__ == "__main__":
+    main()

code/hf_release.py

@@ -4,6 +4,7 @@ Uploads whatever currently exists (idempotent), so it can be run once for the
 code and trained models and again after the campaign for the results, logs,
 figures, and dataset card.  Token is read from the HF_TOKEN environment variable.
 """
+import glob
 import json
 import os
 
@@ -22,6 +23,7 @@ def card():
         p = os.path.join(ROOT, "results", s, "train_summary.json")
         if os.path.exists(p):
             summ[s] = json.load(open(p))
+    has_parquet = os.path.isdir(os.path.join(ROOT, "results", "parquet", "single_bit_upsets"))
     lines = []
     lines.append("---")
     lines.append("license: mit")
@@ -30,10 +32,20 @@ def card():
               "reliability", "radiance-fields", "computer-graphics"]:
         lines.append(f"  - {t}")
     lines.append("pretty_name: Single-Event Upsets in 3D Gaussian Splatting")
-    # This is a code + trained-model + records artifact bundle, not a tabular
-    # dataset; disable the auto dataset-viewer so the file tree is shown instead
-    # of misparsing the per-scene summary JSONs as a few-row table.
-    lines.append("viewer: false")
+    if has_parquet:
+        # Point the dataset viewer at the per-injection Parquet records so it
+        # browses the millions of single-bit upset rows (not the summary JSONs).
+        lines.append("configs:")
+        lines.append("  - config_name: single_bit_upsets")
+        lines.append("    data_files:")
+        lines.append("      - split: train")
+        lines.append("        path: data/single_bit_upsets/*.parquet")
+        lines.append("  - config_name: multi_upset")
+        lines.append("    data_files:")
+        lines.append("      - split: train")
+        lines.append("        path: data/multi_upset/*.parquet")
+    else:
+        lines.append("viewer: false")
     lines.append("---\n")
     lines.append("# Single-Event Upsets in 3D Gaussian Splatting Rendering\n")
     lines.append("Artifacts for the paper *Single-Event Upsets in 3D Gaussian Splatting "
@@ -59,7 +71,8 @@ def card():
     lines.append("```")
     lines.append("code/        training, fault-injection engine, campaign, analysis, figures")
     lines.append("models/      trained gsplat checkpoints per scene (model.pt)")
-    lines.append("results/     aggregate.json, bench.json, multiupset records, train summaries")
+    lines.append("data/        per-injection records as Parquet (browsable in the viewer)")
+    lines.append("results/     aggregate.json, bench.json, multiupset/largescene records, summaries")
     lines.append("logs/        campaign / driver / GPU-utilisation logs")
     lines.append("figures/     regenerated figures, tables, and numbers.tex")
     lines.append("```\n")
@@ -67,13 +80,63 @@ def card():
                  "header comments; the GPU run used an RTX 5090 (sm_120), PyTorch 2.12 / "
                  "CUDA 13, gsplat 1.5.3.\n")
     lines.append("PAPER_URL: __ARXIV_LINK_PLACEHOLDER__\n")
+    if has_parquet:
+        lines.append("The per-injection records are browsable in the dataset viewer "
+                     "(`single_bit_upsets`: one row per single-bit upset, several million "
+                     "rows; `multi_upset`: accumulated-dose records), stored as Parquet under "
+                     "`data/`.\n")
     return "\n".join(lines)
 
 
+FIELD_NAMES = ["means", "scales", "quats", "opacities", "sh0", "shN"]
+BCLASS = {0: "sign", 1: "exp", 2: "mantissa"}
+
+
+def write_parquet(root):
+    """Convert the per-injection .npz shards into viewer-friendly Parquet, one
+    file per (scene, precision), with readable field/bit-class names."""
+    import glob
+    import numpy as np
+    import pandas as pd
+    sb_dir = os.path.join(root, "results", "parquet", "single_bit_upsets")
+    mu_dir = os.path.join(root, "results", "parquet", "multi_upset")
+    os.makedirs(sb_dir, exist_ok=True); os.makedirs(mu_dir, exist_ok=True)
+    n = 0
+    for fp in sorted(glob.glob(os.path.join(root, "results", "campaign", "shard_*.npz"))):
+        d = np.load(fp, allow_pickle=True); a = d["data"]; cols = list(d["cols"]); meta = list(d["meta"])
+        df = pd.DataFrame(a, columns=cols)
+        df["scene"] = meta[0]; df["precision"] = meta[1]
+        df["field"] = df["field_id"].astype(int).map(lambda i: FIELD_NAMES[i])
+        df["bitclass"] = df["bitclass"].astype(int).map(BCLASS)
+        df["guarded"] = fp.endswith("_guard.npz")
+        df = df.drop(columns=["field_id"])
+        df.to_parquet(os.path.join(sb_dir, os.path.basename(fp).replace(".npz", ".parquet")), index=False)
+        n += len(df)
+    for fp in sorted(glob.glob(os.path.join(root, "results", "multiupset", "multiupset_*.npz"))):
+        d = np.load(fp, allow_pickle=True); a = d["data"]; cols = list(d["cols"]); meta = list(d["meta"])
+        df = pd.DataFrame(a, columns=cols)
+        df["scene"] = meta[0]; df["precision"] = meta[1]; df["guarded"] = fp.endswith("_guard.npz")
+        df.to_parquet(os.path.join(mu_dir, os.path.basename(fp).replace(".npz", ".parquet")), index=False)
+    print(f"wrote parquet: {n} single-bit-upset rows")
+    return n
+
+
 def main():
     create_repo(REPO, repo_type="dataset", token=TOK, exist_ok=True, private=False)
     print("repo ready:", REPO)
 
+    # convert per-injection records to Parquet so the dataset viewer can browse
+    # the millions of rows (skips gracefully if the campaign has not produced shards)
+    try:
+        if glob.glob(os.path.join(ROOT, "results", "campaign", "shard_*.npz")):
+            write_parquet(ROOT)
+            api.upload_folder(folder_path=os.path.join(ROOT, "results", "parquet"),
+                              path_in_repo="data", repo_id=REPO, repo_type="dataset",
+                              token=TOK, allow_patterns=["*.parquet"])
+            print("uploaded data/ (parquet)")
+    except Exception as e:
+        print("parquet step skipped:", e)
+
     # dataset card
     cpath = "/tmp/README_hf.md"
     open(cpath, "w").write(card())

code/largescene.py

@@ -55,8 +55,10 @@ def main():
     ap.add_argument("--ply", required=True)
     ap.add_argument("--out", default="/root/seu/results/largescene")
     ap.add_argument("--W", type=int, default=800)
-    ap.add_argument("--mults", default="1,4,8,15,25")
-    ap.add_argument("--vram_budget_gb", type=float, default=26.0)
+    ap.add_argument("--mults", default="1,8,20,35,50")
+    ap.add_argument("--vram_budget_gb", type=float, default=29.0)
+    ap.add_argument("--storm_k", type=int, default=1000)
+    ap.add_argument("--storm_frames", type=int, default=300)
     args = ap.parse_args()
     os.makedirs(args.out, exist_ok=True)
     base, sh, N0 = load_ply(args.ply)
@@ -87,21 +89,65 @@ def main():
                 ng.append(((img[0] - clean[0]).abs().amax(-1) > 1 / 255).float().mean().item())
                 g.append(((gimg[0] - clean[0]).abs().amax(-1) > 1 / 255).float().mean().item())
             del stored, work, clean
+            # effective bandwidth of the guard: it reads+writes only the 14 guarded
+            # components (means 3, scales 3, quats 4, opacity 1, sh0 3); SH-rest skipped
+            guard_bytes = N * 14 * 4 * 2  # read + write
+            guard_bw = guard_bytes / t_guard / 1e9  # GB/s
             row = {"k": k, "N": int(N), "vram_gb": float(vram), "render_ms": t_render * 1e3,
                    "guard_ms": t_guard * 1e3, "mpix_s": float(mpix),
                    "guard_frac": float(t_guard / t_render),
+                   "guard_bw_gbs": float(guard_bw), "param_bits": int(N * 59 * 32),
                    "scalesign_foot_noguard": float(np.mean(ng) * 100),
                    "scalesign_foot_guard": float(np.mean(g) * 100)}
             rows.append(row)
-            print(f"k={k:3d} N={N:10,d} VRAM={vram:5.1f}GB render={t_render*1e3:6.2f}ms "
-                  f"{mpix:7.1f}Mpix/s guard={t_guard*1e3:.3f}ms ({t_guard/t_render*100:.1f}% of render)",
-                  flush=True)
+            print(f"k={k:3d} N={N:11,d} ({N*59*32/1e9:.1f}e9 bits) VRAM={vram:5.1f}GB "
+                  f"render={t_render*1e3:6.2f}ms {mpix:7.1f}Mpix/s guard={t_guard*1e3:.3f}ms "
+                  f"({t_guard/t_render*100:.1f}% render, {guard_bw:.0f}GB/s)", flush=True)
             del params, bounds
             if vram > args.vram_budget_gb:
                 print("vram budget reached, stopping", flush=True); break
         except torch.cuda.OutOfMemoryError:
             print(f"k={k} OOM, stopping", flush=True); break
-    json.dump({"rows": rows, "W": W}, open(os.path.join(args.out, "largescene.json"), "w"), indent=2)
+    # ---- real-time fault-storm latency at a memory-safe large scene ----
+    # the storm needs stored+work copies plus render buffers (~3x params), so cap
+    # the replication at a size that fits rather than the largest swept point.
+    storm = None
+    if rows:
+        kmax = next((r["k"] for r in reversed(rows) if r["N"] <= 18_000_000), rows[0]["k"])
+        try:
+            torch.cuda.empty_cache(); torch.cuda.reset_peak_memory_stats()
+            params = base if kmax == 1 else replicate(base, kmax)
+            N = params["means"].shape[0]
+            bounds = F.compute_bounds(params)
+            stored, work = F.quantize_params(params, "fp32")
+            comps = {f: work[f].reshape(N, -1).shape[1] for f in ["means", "scales", "quats", "opacities", "sh0", "shN"]}
+            FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]
+            rng = np.random.default_rng(0)
+            # sustained latency under a continuous storm of storm_k upsets per frame, guarded
+            import time
+            lat_ng, lat_g = [], []
+            for _ in range(args.storm_frames):
+                sites = []
+                for _ in range(args.storm_k):
+                    field = FIELDS[int(rng.integers(0, 6))]
+                    flat = int(rng.integers(0, N * comps[field])); bit = int(rng.integers(0, 32))
+                    cv, _ = F.flip_one(stored[field], work[field], flat, bit, "fp32"); sites.append((field, flat, cv))
+                torch.cuda.synchronize(); t0 = time.time()
+                gsmodel.render(work, vms[:1], Ks[:1], W, H, sh); torch.cuda.synchronize()
+                lat_ng.append((time.time() - t0) * 1e3)
+                torch.cuda.synchronize(); t0 = time.time()
+                gw = F.apply_guard(work, bounds); gsmodel.render(gw, vms[:1], Ks[:1], W, H, sh); torch.cuda.synchronize()
+                lat_g.append((time.time() - t0) * 1e3)
+                for field, flat, cv in sites:
+                    F.restore_one(work[field], flat, cv)
+            storm = {"N": int(N), "storm_k": args.storm_k, "frames": args.storm_frames,
+                     "lat_noguard_ms_mean": float(np.mean(lat_ng)), "lat_noguard_ms_p99": float(np.percentile(lat_ng, 99)),
+                     "lat_guard_ms_mean": float(np.mean(lat_g)), "lat_guard_ms_p99": float(np.percentile(lat_g, 99))}
+            print(f"STORM N={N:,} k={args.storm_k}/frame x{args.storm_frames}: "
+                  f"no-guard {storm['lat_noguard_ms_mean']:.2f}ms  guard {storm['lat_guard_ms_mean']:.2f}ms", flush=True)
+        except torch.cuda.OutOfMemoryError:
+            print("storm OOM", flush=True)
+    json.dump({"rows": rows, "W": W, "storm": storm}, open(os.path.join(args.out, "largescene.json"), "w"), indent=2)
     print("LARGESCENE_DONE", flush=True)
 
 

code/make_figs.py

@@ -23,7 +23,17 @@ 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"]
-plt.rcParams.update({"font.size": 11, "figure.dpi": 140, "savefig.bbox": "tight"})
+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):
@@ -280,7 +290,7 @@ def main():
             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}[t]\n\\centering\n")
+        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")
@@ -295,7 +305,7 @@ def main():
                              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}[t]\n\\centering\n\\small\n")
+        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 "
@@ -315,7 +325,7 @@ def main():
 
     # guard table
     with open(os.path.join(args.out, "tab_guard.tex"), "w") as f:
-        f.write("\\begin{table}[t]\n\\centering\n")
+        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")
@@ -397,7 +407,7 @@ def main():
                 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}[t]\n\\centering\n\\small\n")
+            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")
@@ -488,6 +498,76 @@ def main():
     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:
@@ -522,6 +602,15 @@ def main():
             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:
@@ -556,6 +645,18 @@ def main():
         "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)

code/realscene_fig.py

@@ -0,0 +1,53 @@
+"""Publication panel for the real-world (truck) scene: clean | faulted | guarded
+| |error|.  We search several orbit views and many candidate sites for the most
+visible scale sign-bit upset, then show the absolute-error map so the corruption
+footprint is legible regardless of the (off-distribution) viewpoint sharpness."""
+import os, numpy as np, torch
+import matplotlib; matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+plt.rcParams.update({"font.family": "serif", "mathtext.fontset": "cm", "font.size": 11,
+                     "savefig.dpi": 220, "savefig.bbox": "tight"})
+import faultlib as F
+from realscene import load_ply, orbit_cameras
+
+PLY = "/root/seu/data/truck.ply"; GEN = "/root/seu/results/generated"
+dev = "cuda"
+params, sh, N = load_ply(PLY)
+W = H = 900
+vms, Ks = orbit_cameras(params["means"], 8, W, H)
+bounds = F.compute_bounds(params)
+stored, work = F.quantize_params(params, "fp32")
+clean, _ = F.render_views(work, vms, Ks, W, H, sh)
+
+rng = np.random.default_rng(7)
+best = (-1.0, 0, 0)  # footprint, view, gaussian
+sc = work["scales"]
+for _ in range(450):
+    v = int(rng.integers(0, 8)); g = int(rng.integers(0, N)); flat = g * 3
+    cv, _ = F.flip_one(stored["scales"], sc, flat, 31, "fp32")
+    img, _ = F.render_views(work, vms[v:v+1], Ks[v:v+1], W, H, sh)
+    F.restore_one(sc, flat, cv)
+    fp = ((img[0] - clean[v]).abs().amax(-1) > 1/255).float().mean().item()
+    if fp > best[0]:
+        best = (fp, v, g)
+fp, v, g = best; flat = g * 3
+print(f"chosen view={v} gaussian={g} footprint={fp*100:.1f}%", flush=True)
+cv, _ = F.flip_one(stored["scales"], sc, flat, 31, "fp32")
+faulted, _ = F.render_views(work, vms[v:v+1], Ks[v:v+1], W, H, sh)
+gw = F.apply_guard(work, bounds)
+guarded, _ = F.render_views(gw, vms[v:v+1], Ks[v:v+1], W, H, sh)
+F.restore_one(sc, flat, cv)
+
+cl = clean[v].clamp(0,1).cpu().numpy(); fa = faulted[0].clamp(0,1).cpu().numpy(); gu = guarded[0].clamp(0,1).cpu().numpy()
+err = np.abs(fa - cl).max(-1)
+
+fig, ax = plt.subplots(1, 4, figsize=(13, 3.5))
+for a in ax: a.set_xticks([]); a.set_yticks([])
+ax[0].imshow(cl); ax[0].set_title("clean")
+ax[1].imshow(fa); ax[1].set_title(f"faulted (footprint {fp*100:.0f}\\%)")
+ax[2].imshow(gu); ax[2].set_title("support guard")
+vmx=float(np.percentile(err,99.5)); im = ax[3].imshow(err, cmap="inferno", vmin=0, vmax=max(vmx,0.02)); ax[3].set_title("$|\\Delta I|_\\infty$ (faulted)")
+cb = fig.colorbar(im, ax=ax[3], fraction=0.046, pad=0.04); cb.set_label("abs. error")
+plt.tight_layout()
+plt.savefig(os.path.join(GEN, "fig_realscene.pdf"), bbox_inches="tight")
+print("WROTE fig_realscene.pdf", flush=True)

code/survival.py

@@ -17,6 +17,10 @@ import numpy as np
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
+plt.rcParams.update({"font.family": "serif", "mathtext.fontset": "cm", "font.size": 12,
+                     "axes.labelsize": 12, "legend.fontsize": 10, "lines.linewidth": 1.9,
+                     "lines.markersize": 5.5, "axes.grid": True, "grid.alpha": 0.25,
+                     "savefig.dpi": 220, "savefig.bbox": "tight"})
 
 # representative SEU rates (upsets per stored bit per hour), order-of-magnitude,
 # from terrestrial/avionic/space soft-error literature.
@@ -127,7 +131,7 @@ def main():
 
     # emit a small table and macro file
     with open(os.path.join(args.out, "tab_survival.tex"), "w") as f:
-        f.write("\\begin{table}[t]\n\\centering\n")
+        f.write("\\begin{table}[tbp]\n\\centering\n")
         f.write("\\caption{Estimated mean time between catastrophic frames for a "
                 "model of $\\modelBits$ stored bits under representative single-event-upset "
                 "rates, without and with the support guard. Rates are order-of-magnitude "