Datasets:
Formats:
parquet
Size:
1M - 10M
Tags:
gaussian-splatting
fault-tolerance
single-event-upset
reliability
radiance-fields
computer-graphics
License:
File size: 9,768 Bytes
f8fe8a4 121e1fb f8fe8a4 121e1fb f8fe8a4 121e1fb f8fe8a4 121e1fb f8fe8a4 121e1fb f8fe8a4 121e1fb f8fe8a4 121e1fb 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 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 | """Publish the SEU-3DGS artifacts to a HuggingFace dataset repo.
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
from huggingface_hub import HfApi, create_repo
REPO = "Lightcap/seu-3dgs"
ROOT = "/root/seu"
SCENES = ["chair", "lego", "ficus", "hotdog"]
TOK = os.environ["HF_TOKEN"]
api = HfApi()
def card():
summ = {}
for s in SCENES:
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")
lines.append("tags:")
for t in ["gaussian-splatting", "fault-tolerance", "single-event-upset",
"reliability", "radiance-fields", "computer-graphics"]:
lines.append(f" - {t}")
lines.append("pretty_name: Single-Event Upsets in 3D Gaussian Splatting")
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 "
"Rendering: Bit-Level Criticality, Spatial Extent, and a Parallel Support "
"Guard* (F. Alpay and B. Kilictas).\n")
lines.append("A trained 3DGS model is a large floating-point array resident in GPU "
"memory, so a single-event upset is one flipped bit in one parameter. "
"This repository releases the fault-injection engine, the trained models, "
"the per-cell aggregated records of more than three million controlled "
"single-bit upsets, the multi-upset records, the throughput measurements, "
"the logs (including the periodic device-utilization trace), and the "
"scripts that regenerate every figure and table in the paper.\n")
if summ:
lines.append("## Trained scenes\n")
lines.append("| scene | primitives | PSNR (dB) | SSIM |")
lines.append("|---|---:|---:|---:|")
for s in SCENES:
if s in summ:
d = summ[s]
lines.append(f"| {s} | {int(d['n_gaussians']):,} | {d['test_psnr']:.2f} | {d['test_ssim']:.4f} |")
lines.append("")
lines.append("## Layout\n")
lines.append("```")
lines.append("code/ training, fault-injection engine, campaign, analysis, figures")
lines.append("models/ trained gsplat checkpoints per scene (model.pt)")
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")
lines.append("Paper: see PAPER_URL below. Reproduce with `code/` following `code/`'s "
"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())
api.upload_file(path_or_fileobj=cpath, path_in_repo="README.md", repo_id=REPO,
repo_type="dataset", token=TOK)
print("uploaded README.md")
# code
if os.path.isdir(os.path.join(ROOT, "code")):
api.upload_folder(folder_path=os.path.join(ROOT, "code"), path_in_repo="code",
repo_id=REPO, repo_type="dataset", token=TOK,
allow_patterns=["*.py", "*.sh"])
print("uploaded code/")
# trained models
for s in SCENES:
mp = os.path.join(ROOT, "results", s, "model.pt")
if os.path.exists(mp):
api.upload_file(path_or_fileobj=mp, path_in_repo=f"models/{s}/model.pt",
repo_id=REPO, repo_type="dataset", token=TOK)
print("uploaded model", s)
# results (aggregated, small)
res_files = ["results/agg/aggregate.json", "results/bench.json"]
for rf in res_files:
p = os.path.join(ROOT, rf)
if os.path.exists(p):
api.upload_file(path_or_fileobj=p, path_in_repo="results/" + os.path.basename(p),
repo_id=REPO, repo_type="dataset", token=TOK)
print("uploaded", rf)
mu = os.path.join(ROOT, "results", "multiupset")
if os.path.isdir(mu):
api.upload_folder(folder_path=mu, path_in_repo="results/multiupset",
repo_id=REPO, repo_type="dataset", token=TOK, allow_patterns=["*.npz"])
print("uploaded multiupset")
for s in SCENES:
ts = os.path.join(ROOT, "results", s, "train_summary.json")
if os.path.exists(ts):
api.upload_file(path_or_fileobj=ts, path_in_repo=f"results/train_summary_{s}.json",
repo_id=REPO, repo_type="dataset", token=TOK)
# logs
if os.path.isdir(os.path.join(ROOT, "logs")):
api.upload_folder(folder_path=os.path.join(ROOT, "logs"), path_in_repo="logs",
repo_id=REPO, repo_type="dataset", token=TOK, allow_patterns=["*.log"])
gu = os.path.join(ROOT, "results", "gpu_util.log")
if os.path.exists(gu):
api.upload_file(path_or_fileobj=gu, path_in_repo="logs/gpu_util.log",
repo_id=REPO, repo_type="dataset", token=TOK)
print("uploaded logs")
# figures (after make_figs)
gen = os.path.join(ROOT, "results", "generated")
if os.path.isdir(gen):
api.upload_folder(folder_path=gen, path_in_repo="figures", repo_id=REPO,
repo_type="dataset", token=TOK)
print("uploaded figures/")
print("HF_RELEASE_DONE https://huggingface.co/datasets/" + REPO)
if __name__ == "__main__":
main()
|