CurveCodec 2: Skeleton-agnostic animation compression with a learned entropy model

Mingyi Shi; Huancheng Lin; Xuelin Chen; Taku Komura

cs.GROct 3, 2026

CurveCodec 2: Skeleton-agnostic animation compression with a learned entropy model

Authors: Mingyi Shi, Huancheng Lin, Xuelin Chen, Taku Komura

Organizations: The University of Hong Kong, Hong Kong · Adobe Research, London, United Kingdom

Abstract

Skeletal motion is stored as every joint's transform at every frame, yet most of it is implied by the body rather than by what the motion is about. Compression is one way to ask what a motion must still say once the body is known, and a production codec must answer it for any skeleton with a stated error bound. Our earlier codec, CurveCodec, matched the mean error of ACL, the production library of modern game engines, with a learned prior over sparse anchors, but not ACL's worst case, and it counted its payload as floats rather than bits. Here we ask where the redundancy of skeletal motion lies and which part of a codec a learned model should take over. Measurements give three answers. At production precision the largest saving comes from predicting each quantized curve from its own past, the second from choosing per joint, in closed loop through the hierarchy, which samples not to code. On the gaps such an encoder leaves, a nearest-neighbour oracle over millions of training samples is no better than linear interpolation, and no learned in-betweener we tried paid for itself. What a network does learn is the distribution of the residuals the codec must send. CurveCodec 2 codes every sub-track as a curve in the log map, quantized in closed loop and thinned to rate-distortion-selected keys, with residuals entropy-coded under a small learned model whose integer inference is bit-exact across platforms. Two contracts are verified on every decoded clip: ACL's own worst case per joint within a stated tolerance, or ACL's mean error per clip. On a held-out test side of 4,472 clips from 33 datasets, CurveCodec 2 needs 0.37x ACL's bytes at ACL's default precision of 0.01 cm under the worst-case contract and 0.22x at 0.1 cm under the mean contract, decodes on one CPU core, and transfers without retraining to a species absent from training. Project page: https://rubbly.cn/publications/curvecodec/

Figures & tables

Figure 1. CurveCodec 2 is a skeleton-agnostic codec for skeletal animation. Twelve rigs from the example set of our online demo, each at three frames of its clip as decoded by CurveCodec 2 at ACL’s default precision of $0.01$ cm, with the clip’s raw size and the size of our stream under each. One model, trained once, codes all of them without retraining. On the held-out test side CurveCodec 2 needs $0.37\times$ ACL’s bytes at this precision, from a bit-exact bitstream that decodes on one CPU core. Project page, online demo, and supplementary material: https://rubbly.cn/publications/curvecodec/ \descTeaser

Figure 2. The two-stage view of animation compression, with the estimated size of our

906

-hour corpus after each stage at

p=0.01

cm (extrapolated from the test side). (a) Deterministic preprocessing shared by ACL and CurveCodec 2: dropping the absent scale sub-tracks and folding sub-tracks that do not move. (b) ACL quantizes the remaining sub-tracks with per-segment range reduction and fixed bit widths (

32.6

GB); CurveCodec 2 codes them as curves with a closed-loop quantizer, RD-selected keys verified through forward kinematics, prediction, and a learned entropy coder (

11.9

GB). The

870

KB model is fixed after training and shared by all clips; it is not counted in the stream. \descTwoStage

Figure 3. Overview of CurveCodec 2. (a) The lossy stage runs once per clip in the encoder. Every animated sub-track becomes a curve in the log map; a closed loop then proposes two kinds of moves, growing a track’s quantization step or dropping one of its keys, decodes the candidate, evaluates the shell error of the affected subtree through forward kinematics, and accepts the move only if the error contract still holds. The skeleton’s geometry is used here and nowhere else; the lossless stage reads only each joint’s depth in the hierarchy. (b) The lossless stage codes the resulting integers. A fixed predictor turns them into residuals, and a small learned model, the only learned component (a causal transformer in the product, an MLP under the max gate), reads features of each curve’s own past and outputs a mixture distribution that drives the rANS coder. The decoder replays the same model in lockstep over all curves, so it reproduces every probability exactly, and reconstructs the clip by Catmull–Rom interpolation between keys. \descPipeline

Figure 4. Where ACL’s bits go on the curated set. (a) Bits per joint-sample after each ACL stage: almost all of the

17.7\times

ratio comes from folding sub-tracks that do not move (

2.84\times

) and from the two-level range reduction with variable bit widths (

3.74\times

). (b) Entropy of ACL’s own quantized symbols relative to the bits ACL spends, for zeroth- to second-order models: an entropy coder with these models on top of ACL saves at most

16

20\,\%

, so a substantially smaller stream needs a different quantizer, not just a better back end. \descAclBudget

Figure 5. How the encoder spends distortion. (a) Fraction of samples kept as keys by joint depth (five development clips, an earlier version of the encoder): the root, whose error reaches every descendant, keeps the most keys, and leaves the fewest. (b) The keys the encoder keeps fall from

79\,\%

16\,\%

of the samples as

p

loosens, yet at

p\leq 0.1

cm more than three quarters of the remaining gaps hide at most two samples. (c) The marginal distortion an encoder move adds per bit it saves, at

p=0.1

cm: removing a key is

5

10\times

cheaper than growing the quantization step or adding a dead zone, which is why the encoder prefers to omit samples once the precision leaves room to. \descKeys

Figure 6. Interpolation from the decoded neighbourhood gains little on the gaps an RD encoder leaves. A nonparametric nearest-neighbour oracle searches every window of the training corpus for the best match of a gap’s own-curve context (

k

is cubic error divided by oracle error;

k>1

is better than cubic). On random gaps (grey) it beats cubic interpolation by up to

1.37\times

and keeps improving with the corpus. On the gaps the RD encoder actually leaves (orange) it is no better than linear interpolation and is flat in the corpus size over the range we could measure. \descOracle

Network role	Representation	$0.01$	$0.1$	$1$ cm
Entropy model	keys + residuals	0.984	0.982	0.983
Correction	keys + fixes	$1.00$ to $1.04$ (unused)
Transform + model	lifting wavelet	1.03	1.09	1.15
In-betweener + model	dyadic grid	1.10	1.35	1.94
Tokenizer	residual VQ	1.10	1.39	2.09
Neural field	per-window INR	–	2.0	3.3

Table 1. Every learned role we tested, each as a complete codec under the iso-mean contract and verified on every clip (dev set; bytes relative to our codec with the MLP entropy model). Only the learned probability model of the residuals pays.

Figure 7. Rate against precision on the held-out test side (

4{,}472

clips,

20.1

33

datasets). Left: bits per joint-sample. Right: our bytes divided by ACL’s on the same clips. Under the max gate (orange), which holds every joint within

5\,\%

of the larger of

p

and ACL’s maximum, CurveCodec 2 needs

0.41\times

0.22\times

ACL’s bytes for

p\leq 0.1

cm; under the iso-mean criterion (blue) the ratio keeps falling to

0.07\times

1

cm. All ratios include the fallback for clips that fail their contract. At

0.3

and

1

cm ACL misses its own precision on part of the data (dashed lines, whole test side); hollow markers on dotted lines repeat the ratio on the clips where ACL keeps at least

99\,\%

of its joint-samples within

p

. \descRD

	ACL				Ours, max gate					Ours, mean gate
$p$ (cm)	bits	Mean	P99	Max	ratio	bits	Mean	P99	Max	ratio	bits	Mean	P99	Max
0.005	18.43	–	–	–	0.414	7.62	–	–	–
0.01	16.38	0.0034	0.0111	0.213	0.373	6.11	0.0048	0.0120	0.211	0.373	6.11	0.0033	0.0119	0.094
0.02	14.39	–	–	–	0.325	4.68	–	–	–
0.05	11.87	0.0166	0.0508	0.539	0.262	3.11	0.0236	0.0540	0.536	0.267	3.17	0.0166	0.0576	0.480
0.1	10.11	0.0333	0.1003	0.916	0.217	2.19	0.0466	0.1054	0.845	0.220	2.23	0.0332	0.1155	0.903

Table 2. Compression and error on the held-out test side (

4{,}472

clips,

342.7

M joint-samples). Ratio is our bytes divided by ACL’s, after the fallback (Sec. 3.3 ); errors are shell errors in cm over all joint-samples of the delivered streams. The max gate holds every joint within

5\,\%

of the larger of

p

and ACL’s maximum and spends the room below the worst case, so its mean error is higher; the mean gate holds ACL’s mean with a flatter distribution (higher P99) and a lower maximum for

p\leq 0.1

cm. At

0.3

and

1

cm ACL misses its own precision on

6.7

and

13.5\,\%

of its joint-samples, and the mean gate’s guard admits the large maxima shown; ratios in parentheses are on the clips where ACL keeps at least

99\,\%

of its joint-samples within

p

Figure 8. Estimated storage of the full 906-hour corpus (

16.17

G joint-samples), extrapolated per dataset from the test side; the full corpus was not encoded. Our bars use the mean-gate product codec after the fallback. Log scale. \descStorage

Panel of Figure 9 — Figure 9. Decoded motion on the held-out test side. Each half-row shows the ground-truth mesh, the skeletons decoded by ACL, by CurveCodec 2 under the max gate, and by CurveCodec 2 under the mean gate, each overlaid on the ground-truth skeleton (blue; the decoded skeleton is orange and thinner, so where they coincide the overlay reads pink), and the mesh driven by our decoded motion. Labels give the clip’s compression ratio against ACL’s raw size and its maximum shell error. Top two rows: $p=0.01$ cm, where all three codecs are visually exact and CurveCodec 2 needs $2$ to $3\times$ fewer bytes than ACL. The dog capture (held out of training) has no mesh of its own; its mesh panels show a Go2 robot for orientation only and its skeleton panels are placed approximately. Bottom row: $p=1$ cm on the same humanoid clip, with insets on the joint that moves the most; ACL reaches $39\times$ and CurveCodec 2 $172\times$ (max gate, ACL’s worst case within tolerance) or $182\times$ (mean gate, same mean error), and the largest joint displacement in the shown frame is $0.46$ to $0.63$ cm for all three. \descQualitative

Data type	$p=0.01$	$0.1$	$1$ cm
native-skeleton mocap	0.358	0.202	0.055
retargeted mocap	0.489	0.322	0.168
converted SMPL	0.413	0.325	0.211
game assets	0.353	0.297	0.219
hands	0.373	0.239	0.129
dog (held-out species)	0.532	0.350	0.168

Table 3. Ratio to ACL by data type and frame rate (test side, mean gate). The gain holds on every type, including game assets and a species absent from training, and grows with the frame rate.

Figure 10. Our bytes divided by ACL’s on each dataset of the held-out test side, iso-mean criterion, at three precisions, sorted by the ratio at

0.01

cm. No dataset is larger than ACL. The gain is largest on long, high-rate captures (BONES-SEED, HiPHI, BEAT) and smallest on short, low-rate clips of small skeletons (HumanAct12, Edinburgh, BFA). The dog (orange) is a species absent from training. \descPerDataset

Max gate, bytes / ACL
	$p=0.01$	$0.1$	$0.3$	$1$ cm
log-map quantizer, every sample	0.978	0.860	–	0.596
+ prediction and context rANS	0.480	0.394	0.406	0.310
+ fine step grid, lookahead, final container	0.458	0.366	0.372	0.307
+ RD keys	0.432	0.274	0.265	0.191
+ component key thinning	0.430	0.271	–	0.187

Table 4. Ablation of the final codecs on held-out data (

311

-clip test subset, all

33

datasets). Top of each block: components added one at a time, bytes relative to ACL. Bottom: one component removed from the final encoder, bytes relative to the final encoder. A failing clip counts at ACL’s bytes. At

1

cm the max-gate rows include five clips of the encoder weakness of Sec. 6.3 ; without them the final codec reaches

0.110

. Prediction is measured on the every-sample codec.

Figure 11. The weakest case: a $192$ -sample, $20$ Hz clip of a $27$ -joint skeleton (HumanAct12) at $p=0.01$ cm. All codecs are visually exact, but CurveCodec 2 saves only a quarter of ACL’s $23.8$ KB ( $0.74\times$ to $0.75\times$ ), against $0.37\times$ on the whole test side: the per-clip header and the cold start of the entropy model are amortized over few samples, and at $20$ Hz few samples can be omitted. \descFailure

Entropy Coding

Entropy coding assigns short codes to likely symbols and longer codes to rare ones, reducing the bits needed to store or transmit data.

See all 25 papers

Mar 10, 2026

ARCHE: Autoregressive Residual Compression with Hyperprior and Excitation

Recent progress in learning-based image compression has demonstrated that end-to-end optimization can substantially outperform traditional codecs by jointly learning compact latent representations and probabilistic entropy models. However, many existing approaches achieve high rate-distortion efficiency at the expense of increased computational cost and limited parallelism. This paper presents ARCHE - Autoregressive Residual Compression with Hyperprior and Excitation, an end-to-end learned image compression framework that balances modeling accuracy and computational efficiency. The proposed architecture unifies hierarchical, spatial, and channel-based priors within a single probabilistic framework, capturing both global and local dependencies in the latent representation of the image, while employing adaptive feature recalibration and residual refinement to enhance latent representation quality. Without relying on recurrent or transformer-based components, ARCHE attains state-of-the-art rate-distortion efficiency: it reduces the BD-Rate by approximately 48% relative to the commonly used benchmark model of Balle et al., 30% relative to the channel-wise autoregressive model of Minnen & Singh and 5% against the VVC Intra codec on the Kodak benchmark dataset. The framework maintains computational efficiency with 95M parameters and 222ms running time per image. Visual comparisons confirm sharper textures and improved color fidelity, particularly at lower bit rates, demonstrating that accurate entropy modeling can be achieved through efficient convolutional designs suitable for practical deployment.

Sofia Iliopoulou, Dimitris Ampeliotis, Athanassios Skodras

Dept. of Electrical and Computer Engineering, University of Patras, Patras, Greece · Dept. of Digital Media and Communication, Ionian University, Argostoli, Greece

Learned Image Compression Autoregressive Modeling

Ask PDF

Jun 28, 2026

Entropy-Coded MS-VQ-VAE with Learned Priors for Ultra-Low Bitrate Video Compression

Learned video codecs based on continuous latent representations struggle to operate reliably below 0.1 bits per pixel~(bpp): without a differentiable rate signal, Lagrangian optimisation cannot effectively trade reconstruction quality for bitrate at extreme compression ratios. We demonstrate that discrete latent representations sidestep this limitation entirely. In a vector-quantized~(VQ) codec, the codebook size~

K

imposes a hard information ceiling of

\log_2 K

bits per symbol; a learned autoregressive prior then exploits the non-uniform distribution of code usage -- which we show follows a power law -- to push actual bitrates well below this ceiling, without any rate-penalty tuning. Building on the MS-VQ-VAE architecture introduced in~\cite{kotthapalli2026msvqvae}, we sweep

K \in \{128, 256, 512, 1024\}

under a uniform training protocol to trace four operating points on the rate-distortion~(RD) curve. We identify and resolve a critical training instability: gradient-based VQ collapses catastrophically at

K \leq 512

, whereas EMA-stabilised codebook updates with dead-code restart maintain full utilisation across all configurations. On 500 UCF101 test clips (

64\!\times\!64

, 32~~frames), our models operate at 0.043-0.064~~bpp -- 3.3-5

\times

below H.264's practical floor and

5

7.6\times

below H.265's floor at this resolution. Every MS-VQ-VAE configuration outperforms H.265 CRF,36 on perceptual quality (LPIPS) despite using

5

7.6\times

fewer bits. At

K{=}1024

, the model surpasses H.265 CRF,36 on LPIPS by a margin of 0.072 absolute while using

5.1\times

fewer bits. Codebook analysis confirms power-law index distributions and 70-85% entropy efficiency, establishing the pipeline as a principled learned entropy coder.

Manikanta Kotthapalli, Banafsheh Rekabdar

Portland State University Department of Computer Science Portland, OR, USA

Learned Image Compression Vector-Quantized Variational Autoencoder Neural Video Compression Video Compression Entropy Coding

Ask PDF

May 23, 2026

Motion-Compensated Weight Compression

Neural network weights are increasingly a bottleneck for deployment, yet most compression pipelines treat layers independently and overlook cross-layer redundancy induced by function-preserving symmetries. We propose Motion-Compensated Weight Compression (MCWC), a weight-only codec that aligns permutation-symmetric blocks (e.g., hidden units and attention heads) to maximize cross-layer correspondence, turning depth into a predictable sequence. In the aligned coordinate system, MCWC uses a lightweight layer-sequential predictor with periodic keyframes and encodes only quantized prediction residuals using a learned entropy model trained under a rate distortion objective. A simple decoder reconstructs deployable weights by entropy decoding, dequantization, predictor-driven reconstruction, and inverse alignment, enabling fast weight materialization for inference. Across Transformer language modeling and vision classification, MCWC improves the rate accuracy Pareto frontier over strong quantization and learned weight-codec baselines, while maintaining competitive decode time. Ablations confirm that alignment, prediction, entropy modeling, and keyframe scheduling are each necessary for the full gains. Our code is available via https://github.com/Ism-ail11/MCWC.

Ismail Lamaakal

Multidisciplinary Faculty of Nador · Mohammed Premier University · Oujda 60000, Morocco

Predictive Coding Weight-Only Quantization Neural Network Compression

Ask PDF

Abstract

Entropy Coding

Explore similar work

ARCHE: Autoregressive Residual Compression with Hyperprior and Excitation

Entropy-Coded MS-VQ-VAE with Learned Priors for Ultra-Low Bitrate Video Compression

Motion-Compensated Weight Compression