Datasets:
Formats:
parquet
Size:
1M - 10M
Tags:
gaussian-splatting
fault-tolerance
single-event-upset
reliability
radiance-fields
computer-graphics
License:
File size: 5,123 Bytes
f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 f138992 f8fe8a4 | 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 | """Multi-upset accumulation: how many simultaneous single-bit upsets can a 3DGS
model absorb before global render quality collapses? Models accumulated
radiation dose. Upsets are drawn uniformly over the whole stored bit budget
(field sampled in proportion to its element x bit count), so each draw is a
realistic random VRAM bit.
"""
import argparse
import json
import os
import time
import numpy as np
import torch
import lpips as lpips_mod
import faultlib as F
from common import ssim, psnr
import gsmodel
FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]
def run(model_path, out_dir, precisions, K, ks, repeats, lpips_fn, seed, log, guard=False):
ckpt = torch.load(model_path, map_location="cuda", weights_only=False)
params = {k: v.cuda().float() for k, v in ckpt["params"].items()}
sh_degree = ckpt["sh_degree"]
W, H = ckpt["W"], ckpt["H"]
scene = ckpt["scene"]
N = params["means"].shape[0]
bounds = F.compute_bounds(params)
n = ckpt["test_viewmats"].shape[0]
idx = np.linspace(0, n - 1, K).round().astype(int)
tvm = ckpt["test_viewmats"][idx].cuda()
tKs = ckpt["test_Ks"][idx].cuda()
def log_print(*a):
msg = " ".join(str(x) for x in a)
print(msg, flush=True)
with open(log, "a") as fh:
fh.write(msg + "\n")
rows = []
for prec in precisions:
stored, work = F.quantize_params(params, prec)
nbits = F.PREC[prec][2]
comps = {f: work[f].reshape(N, -1).shape[1] for f in FIELDS}
# field sampling weights proportional to (#elements * #bits)
weights = np.array([comps[f] * N * nbits for f in FIELDS], dtype=np.float64)
weights /= weights.sum()
clean_img, _ = F.render_views(work, tvm, tKs, W, H, sh_degree)
rng = np.random.default_rng(seed + hash((scene, prec)) % (2 ** 31))
for k in ks:
for r in range(repeats):
sites = [] # (field, flat_idx, clean_val)
for _ in range(k):
fi = rng.choice(6, p=weights)
field = FIELDS[fi]
Cf = comps[field]
flat_idx = int(rng.integers(0, N * Cf))
bit = int(rng.integers(0, nbits))
clean_val, _ = F.flip_one(stored[field], work[field], flat_idx, bit, prec)
sites.append((field, flat_idx, clean_val))
render_in = F.apply_guard(work, bounds) if guard else work
img, cat = F.render_views(render_in, tvm, tKs, W, H, sh_degree)
mse = torch.mean((img - clean_img) ** 2).item()
ps = -10.0 * np.log10(max(mse, 1e-12))
ss = ssim(img.permute(0, 3, 1, 2), clean_img.permute(0, 3, 1, 2)).item()
with torch.no_grad():
lp = lpips_fn(img.permute(0, 3, 1, 2) * 2 - 1,
clean_img.permute(0, 3, 1, 2) * 2 - 1).mean().item()
for field, flat_idx, clean_val in sites:
F.restore_one(work[field], flat_idx, clean_val)
rows.append((k, r, ps, ss, lp, float(mse), int(cat)))
sub = [x for x in rows if x[0] == k]
pss = np.array([x[2] for x in sub])
log_print(f" [{scene}/{prec}] k={k:6d} meanPSNR={pss.mean():6.2f} "
f"minPSNR={pss.min():6.2f} catRate={np.mean([x[6] for x in sub]):.3f}")
arr = np.array(rows, dtype=np.float64)
tag = f"{scene}_{prec}" + ("_guard" if guard else "")
np.savez_compressed(os.path.join(out_dir, f"multiupset_{tag}.npz"),
data=arr, cols=np.array(["k", "rep", "psnr", "ssim", "lpips", "mse", "cat"]),
meta=np.array([scene, prec, str(N)]))
rows = []
log_print(f" MULTIUPSET done {scene} guard={guard}")
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--results_dir", default="/root/seu/results")
ap.add_argument("--scenes", default="chair,lego,ficus,hotdog")
ap.add_argument("--out", default="/root/seu/results/multiupset")
ap.add_argument("--precisions", default="fp32,fp16,bf16")
ap.add_argument("--K", type=int, default=8)
ap.add_argument("--repeats", type=int, default=60)
ap.add_argument("--ks", default="1,2,5,10,20,50,100,200,500,1000,2000,5000,10000,20000")
ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--guard", type=int, default=0)
args = ap.parse_args()
os.makedirs(args.out, exist_ok=True)
log = os.path.join(args.out, "multiupset.log")
ks = [int(x) for x in args.ks.split(",")]
lpips_fn = lpips_mod.LPIPS(net="alex").cuda().eval()
for p in lpips_fn.parameters():
p.requires_grad_(False)
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, args.precisions.split(","), args.K, ks, args.repeats,
lpips_fn, args.seed, log, guard=bool(args.guard))
print("MULTIUPSET_DONE", flush=True)
if __name__ == "__main__":
main()
|