13_pixel_arm/README.md

Pixel arm: the best pixel-root memory (window model + 8-step update head; 2026-10-31)

The current best pixel (root) memory on the orbit benchmark. It replaces the previous pixel arm (Bk, formerly 12_pixel_arm_bk/, removed 2026-11-01): same window model, a head retrained for 8 update steps, and a lighter evaluation configuration. It matches Bk's PSNR at the end of the stream (−0.00 ± 0.03 dB on test33) with better LPIPS (−.010), 3.75 x less memory and about 3.5 x the speed.

• model_001000.pt: the window model (3D-Belief trunk, proposal head, Gaussian decoder; EMA) of outputs/joint_j1keptlr, step 1000. The same file as Bk's (sha256 unchanged); args['decoder_from'] is repo-relative (the only change from the cluster original).
• upd_000800.pt: the learned root update head (EMA, ['ema']), retrained for 8 update steps (outputs/opt_it8, command_head.json): head only, from Bk's head, 800 steps, head lr 2.5e-5, seed 3, rollouts over 400 DL3DV training orbits (data/orbit_cache/dl3dv_train, disjoint from val33 / test33) with the 5 deg / .08 pose store, replay 8 views at a time and kept targets. Its ['args'] still carries absolute cluster paths inherited from older heads; loading reads only ['ema'] and inner_lpips.
• command_window.json / command_j1.json: the window model's training (J1, then Bk's +1000 steps at half lr); command_eval_test33.json: the evaluation that produced the numbers below (shard 0 of 4).

Needs, besides these files (run from the repo root, branch amodal-completion, commit b7f7e0a or later):

• the decoder construction files free_completion_20260927/checkpoints/ray/step002000 from 03_checkpoints_streaming.zip, at outputs/free_completion_20260927/checkpoints/ray/step002000 (the snapshot's weights are loaded over it);
• the 3D-Belief prior 3d_belief_re10k_256.pt at $FLC_BELIEF_CKPT (read when the trunk is built; not in this repo);
• for --sky-layer: the sky segmenter nvidia/segformer-b0-finetuned-ade-512-512 at checkpoints/segformer_b0_ade;
• the orbit caches data/orbit_cache/dl3dv_test33 (and dl3dv_val33) from 11_orbit_eval_data/.

How it is run

Each 6-frame window (advancing 2 frames) is written into the root memory; the update head then refines the roots for 8 steps, fitting the window's frames plus a self-replay of every stored past pose that overlaps the update. A pose is stored when it is > 10 deg or > 0.15 x scene depth from every stored pose; its replay target is kept: the memory's own render right after the last window that observed that pose or its cell (uint8, 256 px). Lossless speed-ups (half-precision state and roots, a lean bookkeeping TSDF, a cheaper exact gradient), every render on a 5 x 5 Gaussian lattice per root (25 Gaussians), pruning by opacity mass, a short lifetime for the update state of roots not updated recently, and a sky layer (a direction-only panorama of observed sky behind the Gaussians; far views skip roots that render mostly on sky).

No past real frame is stored: each window's frames are used for its write and update and dropped. Kept per stream (test33, ~348 MB at the end): roots, update-head state, bookkeeping TSDF, replay poses (+ 32 x 32 caches rendered from the memory), kept replay targets (the memory's own renders), and the sky panorama + masks (one fused colour per observed sky direction, the only stored content derived from real pixels).

python scripts/unified/eval_long_stream.py --snapshot 13_pixel_arm/model_001000.pt --root-updater 13_pixel_arm/upd_000800.pt \
  --replay-chunk 8 --replay-store cell --fast-grad --state-half --roots-half --tsdf-lean --tsdf-carve 0 \
  --lod 5 --prune-mass .4 --state-ttl 4 --tsdf-size .1 --sky-layer --sky-thr 2 --sky-far 16 \
  --admit-angle 10 --admit-dist .15 --ru-iters 8 \
  --data data/orbit_cache/dl3dv_test33 --clips 33 --loops 2 --async-period 0 --out <dir>

For far overview renders only, --far-cap 4 --far-depth .15 (with --sky-far) also caps Gaussians at 4 source pixels and skips those in front of the TSDF surface at that camera; render-only, the memory and near-path renders are unchanged.

Results

dl3dv_test33 (33 DL3DV test orbits), walked twice (6 orbits); after every window the memory renders the first orbit's held-out frames; all pixels (holes count); one seed; one process per GPU (three H100, one H200). test33_orbit.png (orbit curves, per-scene changes, tiles) and test33_orbit.json (the numbers below).

test33, 6 orbits, all pixels	PSNR orbit 1 / 3 / 6	orbit 6 − orbit 1	walk 2 (6 − 3)	LPIPS at 6	MB at the end	s per frame
pixel arm (this)	17.36 / 18.08 / 18.12	+0.75 ± 0.10 (29 / 33 rise)	+0.04 (19 / 33)	.394	348	2.09
frame memory (Context-as-Memory style, our window model)	16.27 / 16.52 / 16.52	+0.26 ± 0.25	0.00	.382	17	0.04
Gen3R, frame buffer (8 scenes)	19.29 / 17.30 / 17.43	−1.86	+0.13	.301
SPMem TSDF (same window predictions)	14.20 / 14.73 / 14.51	+0.31 ± 0.20	−0.22	.627	147	0.05
plain point accumulation	12.35 / 11.85 / 11.65	−0.69 ± 0.09	−0.20	.753	78	0.15

LPIPS of this arm at orbits 1 / 3 / 6: .417 / .389 / .394. Bk on the same scenes: 17.42 / 18.15 / 18.12, +0.69, 1.1-1.3 GB, 5.1 s per frame. dl3dv_val8 (8 scenes, the selection set): 16.44 / 17.10 / 17.08, +0.64, LPIPS .435, 367 MB, 2.37 s per frame (Bk 8.23 s, matched GPUs). A window takes ~4.4 s on test33 (6-frame windows advancing 2, two walks), most of it the replay of ~44 stored poses per window.

Known limits: the mean over the first orbit's views rises for about 1.5 orbits and then stays flat; views the memory already rendered well slowly lose detail (0.7-1.1 dB below their own peak) while weaker views catch up. Far views show haze from a few hundred runaway roots; the far-view filter hides it, it is not removed. Runs are not bit-reproducible (repeat runs of the same flags differ by up to ~0.1 dB per scene).

sha256 model_001000.pt: 08e30bdaac8ddb560151384df06e16bc88606cbe86915bb92d587e16e522110e sha256 upd_000800.pt: 7a1d6c3a76c68102f278048a8869ab589e4bab48e80250e9805eaaa428d99d5d