code/train_gs.py

"""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()