Datasets:
Formats:
parquet
Size:
1M - 10M
Tags:
gaussian-splatting
fault-tolerance
single-event-upset
reliability
radiance-fields
computer-graphics
License:
File size: 4,922 Bytes
f138992 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | """E10: resilience versus primitive count.
A trained model is subsampled to a range of primitive counts N (and real scenes,
which carry millions of primitives, extend the high end). For each N we run an
accumulated-dose sweep and record the dose k at which the mean PSNR drops below
30 dB, the redundancy budget, plus the mean footprint of a scale-sign upset. If
redundancy is the source of resilience, the budget should grow with N while the
per-upset footprint stays roughly constant.
"""
import argparse
import json
import os
import numpy as np
import torch
import lpips as lpips_mod
import faultlib as F
from common import ssim
import gsmodel
FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]
def subsample(params, n_keep, rng):
N = params["means"].shape[0]
if n_keep >= N:
return {k: v.clone() for k, v in params.items()}, N
idx = torch.from_numpy(rng.choice(N, size=n_keep, replace=False)).long().cuda()
return {k: v[idx].contiguous() for k, v in params.items()}, n_keep
def dose_curve(work, stored, comps, N, nbits, tvm, tKs, W, H, sh, lpips_fn, ks, repeats, rng):
clean, _ = F.render_views(work, tvm, tKs, W, H, sh)
weights = np.array([comps[f] * N * nbits for f in FIELDS], float); weights /= weights.sum()
out = {}
for k in ks:
ps = []
for _ in range(repeats):
sites = []
for _ in range(k):
fi = rng.choice(6, p=weights); field = FIELDS[fi]
flat = int(rng.integers(0, N * comps[field])); bit = int(rng.integers(0, nbits))
cv, _ = F.flip_one(stored[field], work[field], flat, bit, "fp32"); sites.append((field, flat, cv))
img, _ = F.render_views(work, tvm, tKs, W, H, sh)
mse = torch.mean((img - clean) ** 2).item()
ps.append(-10.0 * np.log10(max(mse, 1e-12)))
for field, flat, cv in sites:
F.restore_one(work[field], flat, cv)
out[k] = float(np.mean(ps))
return out
def k_at_30(curve):
ks = sorted(curve)
for k in ks:
if curve[k] < 30.0:
return k
return ks[-1]
def run(model_path, out, fracs, ks, repeats, lpips_fn, seed, log):
ck = torch.load(model_path, map_location="cuda", weights_only=False)
base = {k: v.cuda().float() for k, v in ck["params"].items()}
sh, W, H = ck["sh_degree"], ck["W"], ck["H"]
scene = ck["scene"]
Nbase = base["means"].shape[0]
tvm = ck["test_viewmats"][:6].cuda(); tKs = ck["test_Ks"][:6].cuda()
rng = np.random.default_rng(seed)
def lg(*a):
m = " ".join(str(x) for x in a); print(m, flush=True); open(log, "a").write(m + "\n")
rows = []
for fr in fracs:
n_keep = max(2000, int(Nbase * fr))
sub, N = subsample(base, n_keep, rng)
stored, work = F.quantize_params(sub, "fp32")
comps = {f: work[f].reshape(N, -1).shape[1] for f in FIELDS}
curve = dose_curve(work, stored, comps, N, 32, tvm, tKs, W, H, sh, lpips_fn, ks, repeats, rng)
# scale-sign footprint at this N (mean over a sample)
clean, _ = F.render_views(work, tvm, tKs, W, H, sh)
foots = []
for _ in range(80):
g = int(rng.integers(0, N)); flat = g * 3
cv, _ = F.flip_one(stored["scales"], work["scales"], flat, 31, "fp32")
img, _ = F.render_views(work, tvm, tKs, W, H, sh)
F.restore_one(work["scales"], flat, cv)
foots.append(((img - clean).abs().amax(-1) > 1 / 255).float().mean().item())
k30 = k_at_30(curve)
rows.append({"N": N, "k30": k30, "scalesign_footprint": float(np.mean(foots) * 100),
"curve": curve})
lg(f"[{scene}] N={N:8d} k30={k30:6d} scalesign_foot={np.mean(foots)*100:.2f}%")
json.dump({"scene": scene, "Nbase": Nbase, "rows": rows},
open(os.path.join(out, f"scaling_{scene}.json"), "w"), indent=2)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--results_dir", default="/root/seu/results")
ap.add_argument("--scenes", default="chair,lego")
ap.add_argument("--out", default="/root/seu/results/scaling")
ap.add_argument("--fracs", default="0.05,0.1,0.25,0.5,1.0")
ap.add_argument("--ks", default="10,50,200,1000,5000,20000,50000")
ap.add_argument("--repeats", type=int, default=30)
ap.add_argument("--seed", type=int, default=0)
args = ap.parse_args()
os.makedirs(args.out, exist_ok=True)
log = os.path.join(args.out, "scaling.log")
fracs = [float(x) for x in args.fracs.split(",")]
ks = [int(x) for x in args.ks.split(",")]
lpips_fn = None
for sc in args.scenes.split(","):
mp = os.path.join(args.results_dir, sc, "model.pt")
if os.path.exists(mp):
run(mp, args.out, fracs, ks, args.repeats, lpips_fn, args.seed, log)
print("SCALING_DONE", flush=True)
if __name__ == "__main__":
main()
|