"""Train a 3D Gaussian Splatting model on a NeRF-synthetic scene with gsplat's DefaultStrategy densification. Saves the trained parameters and a held-out test camera set for the fault-injection campaign. Usage: python train_gs.py --scene_dir DATA/lego --out OUT/lego --iters 7000 """ import argparse import os import time import math import json import numpy as np import torch import torch.nn as nn from common import load_blender, psnr, ssim, inverse_sigmoid import gsmodel from gsplat.strategy import DefaultStrategy def build_model(n_init: int, scene_scale: float, sh_degree: int, device: str): M = (sh_degree + 1) ** 2 # total SH coeffs # init points uniformly in a cube roughly bounding the object half = 1.3 means = (torch.rand(n_init, 3, device=device) * 2 - 1) * half # init isotropic scale near mean neighbour spacing init_scale = math.log(0.05) scales = torch.full((n_init, 3), init_scale, device=device) quats = torch.zeros(n_init, 4, device=device) quats[:, 0] = 1.0 opacities = torch.full((n_init,), inverse_sigmoid(0.1), device=device) sh0 = torch.zeros(n_init, 1, 3, device=device) shN = torch.zeros(n_init, M - 1, 3, device=device) params = nn.ParameterDict({ "means": nn.Parameter(means), "scales": nn.Parameter(scales), "quats": nn.Parameter(quats), "opacities": nn.Parameter(opacities), "sh0": nn.Parameter(sh0), "shN": nn.Parameter(shN), }).to(device) lrs = { "means": 1.6e-4 * scene_scale, "scales": 5e-3, "quats": 1e-3, "opacities": 5e-2, "sh0": 2.5e-3, "shN": 2.5e-3 / 20.0, } optimizers = { k: torch.optim.Adam([{"params": params[k], "lr": lrs[k], "name": k}], eps=1e-15) for k in params.keys() } return params, optimizers, lrs def main(): ap = argparse.ArgumentParser() ap.add_argument("--scene_dir", required=True) ap.add_argument("--out", required=True) ap.add_argument("--iters", type=int, default=12000) ap.add_argument("--downscale", type=int, default=2) ap.add_argument("--sh_degree", type=int, default=3) ap.add_argument("--n_init", type=int, default=100000) ap.add_argument("--seed", type=int, default=0) args = ap.parse_args() os.makedirs(args.out, exist_ok=True) device = "cuda" torch.manual_seed(args.seed) np.random.seed(args.seed) imgs, viewmats, Ks, W, H = load_blender(args.scene_dir, "train", args.downscale, device) n_train = imgs.shape[0] # scene scale = max camera distance from the mean camera centre cam_centers = torch.inverse(viewmats)[:, :3, 3] centroid = cam_centers.mean(0) scene_scale = float((cam_centers - centroid).norm(dim=-1).max().item()) print(f"scene_scale={scene_scale:.3f} train_views={n_train} WxH={W}x{H}", flush=True) params, optimizers, lrs = build_model(args.n_init, scene_scale, args.sh_degree, device) strategy = DefaultStrategy(refine_stop_iter=int(args.iters * 0.6), reset_every=3000, refine_every=100, absgrad=True, grow_grad2d=6e-4, verbose=False) strategy.check_sanity(params, optimizers) state = strategy.initialize_state(scene_scale=scene_scale) white = torch.ones(1, 3, device=device) t0 = time.time() for step in range(args.iters): active_sh = min(step // 1000, args.sh_degree) idx = np.random.randint(0, n_train) vm = viewmats[idx:idx + 1] K = Ks[idx:idx + 1] gt = imgs[idx] # H,W,3 colors = gsmodel.colors_from_params(params) from gsplat import rasterization renders, alphas, info = rasterization( params["means"], params["quats"], torch.exp(params["scales"]), torch.sigmoid(params["opacities"]), colors, vm, K, W, H, sh_degree=active_sh, packed=True, absgrad=True, rasterize_mode="classic") renders = renders + (1.0 - alphas) # composite over white pred = renders[0].clamp(0, 1) # H,W,3 l1 = (pred - gt).abs().mean() dssim = 1.0 - ssim(pred.permute(2, 0, 1)[None], gt.permute(2, 0, 1)[None]) loss = 0.8 * l1 + 0.2 * dssim strategy.step_pre_backward(params, optimizers, state, step, info) loss.backward() strategy.step_post_backward(params, optimizers, state, step, info, packed=True) for opt in optimizers.values(): opt.step() opt.zero_grad(set_to_none=True) # exponential decay of means lr decay = 0.01 ** (step / args.iters) optimizers["means"].param_groups[0]["lr"] = lrs["means"] * decay if step % 500 == 0 or step == args.iters - 1: with torch.no_grad(): p = psnr(pred, gt).item() print(f"step {step:5d} loss {loss.item():.4f} psnr {p:5.2f} " f"N {gsmodel.num_gaussians(params):7d} t {time.time()-t0:6.1f}s", flush=True) # ---- evaluation on held-out test views ---- timgs, tvm, tKs, _, _ = load_blender(args.scene_dir, "test", args.downscale, device, max_views=25) psnrs, ssims = [], [] with torch.no_grad(): for i in range(timgs.shape[0]): r, _, _ = gsmodel.render(params, tvm[i:i + 1], tKs[i:i + 1], W, H, args.sh_degree) pr = r[0].clamp(0, 1) psnrs.append(psnr(pr, timgs[i]).item()) ssims.append(ssim(pr.permute(2, 0, 1)[None], timgs[i].permute(2, 0, 1)[None]).item()) test_psnr = float(np.mean(psnrs)) test_ssim = float(np.mean(ssims)) print(f"TEST psnr={test_psnr:.3f} ssim={test_ssim:.4f} over {len(psnrs)} views", flush=True) # ---- save model + cameras ---- cpu = {k: params[k].detach().cpu() for k in params.keys()} torch.save({ "params": cpu, "sh_degree": args.sh_degree, "W": W, "H": H, "scene_scale": scene_scale, "test_viewmats": tvm.cpu(), "test_Ks": tKs.cpu(), "test_psnr": test_psnr, "test_ssim": test_ssim, "n_gaussians": gsmodel.num_gaussians(params), "scene": os.path.basename(args.scene_dir.rstrip("/")), }, os.path.join(args.out, "model.pt")) # a couple of reference renders for sanity figures import imageio.v2 as imageio with torch.no_grad(): r, _, _ = gsmodel.render(params, tvm[0:1], tKs[0:1], W, H, args.sh_degree) ref = (r[0].clamp(0, 1).cpu().numpy() * 255).astype(np.uint8) imageio.imwrite(os.path.join(args.out, "ref_view0.png"), ref) gt0 = (timgs[0].cpu().numpy() * 255).astype(np.uint8) imageio.imwrite(os.path.join(args.out, "gt_view0.png"), gt0) with open(os.path.join(args.out, "train_summary.json"), "w") as f: json.dump({"scene": os.path.basename(args.scene_dir.rstrip("/")), "test_psnr": test_psnr, "test_ssim": test_ssim, "n_gaussians": int(gsmodel.num_gaussians(params)), "iters": args.iters, "W": W, "H": H, "scene_scale": scene_scale}, f, indent=2) print("SAVED", os.path.join(args.out, "model.pt"), flush=True) if __name__ == "__main__": main()