Animatable 3D human avatars are usually split into two parts. One is a canonical body, the person's identity in a rest pose. The other is a pose-dependent correction that adds wrinkles, bulges and shadows for each new pose. Both parts are trained as if every parameter update were free to write. That assumption breaks in two places. On the systems side, avatars that outgrow GPU and host memory must spill onto slower storage such as flash or persistent memory, where writing costs far more than reading. On the generative side, avatars built from a single photo are trained on views hallucinated by a diffusion model, and the views that disagree with the rest are what carve duplicate faces onto the back of a head. This is the "Janus problem."
We propose one mechanism aimed at both failures. Before any update is written to the canonical store, it must agree across the views and poses that observe it. Updates that agree across views and across poses are identity, so they are committed to the canonical store, in large sequential blocks, on the slow medium. Updates that agree across views but change with pose are wrinkles and shadows, so they go to a small pose-dependent residual held in fast memory. Updates that disagree across views at the same pose are discarded as hallucination noise. The claim is that this single gate cuts writes to slow storage, separates identity from pose-dependent appearance, and blocks Janus artifacts from being written into identity.
Core Claim
The design borrows from graph processing on non-volatile RAM. Sage keeps a huge graph's edges read-only in NVRAM and holds only small mutable vertex state in DRAM. On ClueWeb this ran within 1.01× of DRAM-only execution. Sage gets this for free because edges never change during traversal. Its limitation, and our motivation, is that avatar training has no such free immutability: the canonical Gaussians, meaning the 3D blob primitives used by Gaussian splatting, are updated at every step.
We claim that near-immutability can be created rather than assumed. If canonical updates are held back until they pass an agreement test, the canonical store becomes mostly read-only. What remains of its write traffic is sparse and sequential. We define $g_{i,v}$ as the accumulated gradient on canonical block $i$ (a group of Gaussians or a UV texel tile) from view $v$, gathered in a DRAM ledger. The agreement score of block $i$ over the $V_i$ views that observe it is
$$a_i = \frac{\lVert \sum_{v \in V_i} g_{i,v} \rVert}{\sum_{v \in V_i} \lVert g_{i,v} \rVert}.$$
The score lies between 0 and 1 and equals 1 only when all views push the block the same way. A block is committed when $a_i > \tau$ and $V_i$ spans at least $k$ distinct azimuth bins.
A second score is computed the same way, but across pose clusters instead of views. When that score is low while the view-agreement score is high, the gradient is routed to the pose residual instead of the canonical store.
For cost accounting we use the asymmetric model of Sorting with Asymmetric Read and Write Costs. In that model reads cost 1 and writes cost $\omega > 1$, so the total slow-tier cost is $C = R + \omega W$, where $R$ and $W$ count block reads and writes. The proposal succeeds on the systems axis if it reduces $W$ enough to lower $C$ for realistic $\omega$, without losing rendering quality.
Research Program
The base model is a Gaussian avatar with an SMPL-X-aligned canonical map and a pose-conditioned decoder, close to Dream, Lift, Animate and GaussianAvatar. That family supplies the separation between canonical state and pose-dependent offsets that our gate routes into. We add three components.
The first is the DRAM gradient ledger, together with a commit policy that flushes passing blocks to the slow tier in sorted, sequential order. Sequential order matters because NGraph reports that random NVM writes degrade far more than sequential ones.
The second is a pose-space router. It sends view-consistent but pose-varying gradient into a compact residual held on the GPU. That residual can be a factorized tri-plane in the style of NECA, which reaches 28.5 PSNR on ZJU-MoCap with about 18M parameters.
The third is a placement policy. Optimizer moments for uncommitted blocks stay in DRAM. Moments for committed blocks are recomputed rather than persisted. This removes the "hidden writes" from Adam's momentum state that the file flags as the open problem with iterative solvers on NVM. The policy is motivated by Micro-architectural Analysis of OLAP Systems on Persistent Memory, which attributes a 1.4× slowdown to writes of intermediate state.
For the generative regime, the training views come from a multi-view generator as in Dream, Lift, Animate. Each block is then observed by several hallucinated views. The view-agreement test acts as a cheap, local consistency filter, without the full reconstruct-and-rerender loop used by Carve3D.
The slow tier will be measured on a real NVMe flash SSD. We will also emulate the medium with injected write delays for a sweep of $\omega$ values, since we have no access to phase-change hardware.
Baselines
The naive reference point is the unmodified avatar trained with everything in GPU memory and every step writing all touched parameters. This sets the quality ceiling. Its write count is measured by logging parameter updates as if they were written to a slow tier.
The strongest systems competitor is CLM. CLM offloads appearance attributes and Adam state to host memory and orders cameras to reuse cached Gaussians. It reports 25.15 PSNR on BigCity and scaling to 102.2M Gaussians on one RTX 4090, but only on static scenes. We found no reported result on Lacuna for CLM on dynamic avatars. We will therefore port CLM's offloading and camera ordering to the same avatar model, with its spill tier pointed at the same SSD. We will tune its microbatch size with the same budget as our threshold $\tau$.
A write-coalescing cache competitor follows ARW, which keeps dirty lines resident longer and reports 47.4% less PCM write traffic than LRU on SPLASH-2/PARSEC. We will apply it at block granularity, with the same DRAM budget as our ledger.
The quality competitors are fixed by benchmark. On ActorsHQ, Dream, Lift, Animate reports 25.58 PSNR and 0.9279 SSIM. On THUman4.0, TexVocab reports 32.09 PSNR on novel poses. On ZJU-MoCap, NECA reports 28.5 PSNR.
The key ablation is a periodic-flush control. It accumulates gradients in the same DRAM ledger and flushes every $m$ steps, with $m$ chosen to match our total write count exactly. It isolates whether the agreement test, rather than mere batching, is doing the work.
Beating the baselines means two things at once. On the systems side, lower $C$ than CLM and ARW at every $\omega$ in the sweep. On the quality side, PSNR within 0.3 dB of the naive reference on captured data. In the generative regime, beating them means lower Janus rates than periodic flush at matched writes.
Why not just…?
Why not just use a bigger GPU or several GPUs? For captured single-subject avatars this alternative is a real threat, and we will report the memory size at which our method stops mattering. The argument for our method is about trend and deployment. AI and Memory Wall reports that GPU memory capacity grows about 2× every two years while model demands grow far faster. Persistent storage of many avatars on edge devices is also a write-asymmetric medium by construction. Separately, the Janus claim does not depend on memory size at all.
Why not just batch writes and flush periodically? This is the strongest threat to the systems claim, which is why the matched-write periodic-flush ablation is central. If periodic flush matches our quality, Janus rate and $C$, then the systems contribution reduces to ordinary write coalescing and we will say so. The remaining question would then be whether the routing still separates identity from pose-dependent appearance better than the base decoder does.
Why not just fix Janus with a parametric anchor or a consistency reward? Anchoring to SMPL or a 3D morphable model, as in Morphable Diffusion or Dream, Lift, Animate's UV latent, already suppresses many Janus faces. Our gate sits on top of that anchor and does not replace it. The open question is the residual artifacts that Dream, Lift, Animate itself reports propagating from its generation stage. Carve3D's reward lowers MRC to 0.0606 from 0.0892 on DreamFusion prompts. Here MRC is the multi-view reconstruction consistency score: the generated views are reconstructed in 3D, re-rendered, and compared to the originals by perceptual (LPIPS) error, with lower meaning more consistent. Carve3D gets there only by fine-tuning a 2.6B-parameter diffusion model through a reconstruction loop. We test whether a free, training-time filter recovers part of that gain. Fine-tuning the generator and gating its outputs are complementary, and we will also run the combination.
Proposed Experiments
The first decisive check runs on captured data: ActorsHQ, THUman4.0 and ZJU-MoCap. For each method we report novel-pose PSNR, SSIM and LPIPS, slow-tier block writes $W$, $C$ across $\omega$ values from 2 to 100, and wall-clock time on the real SSD. The hypothesis fails if the agreement gate cannot lower $W$ below the periodic-flush control at equal quality.
The second check runs in the generative regime. We generate single-image avatars from SHHQ and from held-out ActorsHQ frames, using Dream, Lift, Animate's pipeline with and without the gate. We then measure MRC computed as Carve3D defines it. We found no reported avatar-specific MRC on Lacuna, so all MRC numbers will be our own. We also measure a Janus rate, defined as the fraction of back-azimuth renders in which an off-the-shelf face detector fires.
The third check probes the disentanglement claim. We swap canonical stores between subjects while keeping each subject's pose residual. If the gate separates identity from pose-dependent appearance correctly, wrinkles should follow the pose residual and skin and clothing color should follow the canonical store. If instead identity leaks into the residual, the routing has failed even if the write savings hold.
Finally, a sweep over $\tau$ and $k$ traces the trade-off curves between writes, quality and Janus rate. These curves indicate whether one setting serves both the systems goal and the consistency goal, or whether the two pull the threshold in opposite directions.
References
- Sage: Parallel Semi-Asymmetric Graph Algorithms for NVRAMs
- Sorting with Asymmetric Read and Write Costs
- Dream, Lift, Animate: From Single Images to Animatable Gaussian Avatars
- GaussianAvatar: Towards Realistic Human Avatar Modeling from a Single Video via Animatable 3D Gaussians
- NGraph: Parallel Graph Processing in Hybrid Memory Systems
- NECA: Neural Customizable Human Avatar
- Micro-architectural Analysis of OLAP Systems on Persistent Memory
- Carve3D: Improving Multi-view Reconstruction Consistency for Diffusion Models with RL Finetuning
- CLM: Removing the GPU Memory Barrier for 3D Gaussian Splatting
- ARW: Efficient Replacement Policies for Phase Change Memory and NAND Flash
- TexVocab: Texture Vocabulary-conditioned Human Avatars
- AI and Memory Wall
- Morphable Diffusion: 3D-Consistent Diffusion for Single-image Avatar Creation