FMT Brings Fixed-Step Parallel Decoding to Lossless Image Compression
Summary:FMT (Fixed-step Multiscale Tree) redesigns lossless image coding as a coarse-to-fine multiscale tree whose decoding order and rANS entropy coder are co-designed. Values within a step are independent, allowing a GPU to predict and decode them concurrently while rANS lanes carry entropy states across steps; the authors say the sequential depth no longer grows with image size. In their tests, a rule-based FMT codec without a neural network beats NVIDIA HTJ2K in both compressed size and speed. A la
Core Mechanism: Remove Serial Waiting, Not Just FLOPs
FMT addresses the central deployment conflict in learned lossless compression: files are often smaller than those produced by classical codecs, yet opening a photograph can still take seconds. The paper attributes much of the delay to waiting rather than computation. Neural predictors must wait for the values used as conditions, while entropy decoders read symbols sequentially and update their states in order.
A conventional arithmetic or ANS decoder can be approximated as s(i+1) = Update(s(i), symbol(i)). Because each state depends on the previous one, symbol-level dependencies create a narrow serial critical path even when the GPU can execute many arithmetic operations concurrently. FMT changes the image representation first, then adapts both prediction and entropy coding to the new schedule.
The image is stored as a coarse-to-fine multiscale tree. According to the paper, values within a step are independent, allowing the GPU to predict them in batches rather than waiting for each pixel's conditioning value. Parallel rANS lanes maintain range-ANS states independently and carry those states from one step to the next, converting a symbol-at-a-time read chain into concurrent decoding.
A useful engineering abstraction is T_serial ≈ N × (t_wait + t_ans) for a conventional path, versus T_FMT ≈ D × (t_wave + t_barrier) + T_tail for FMT. Here, N is the number of pixels or symbols, while D denotes the fixed sequential depth that the authors say does not grow with image size. Fixed steps refer to the controlled critical-path depth, not constant total computation, memory use, or end-to-end latency. Aggregate work still grows with image size, and realized speedup remains bounded by memory bandwidth, occupancy, kernel launch overhead, and synchronization barriers.
Co-Designing the Format, Predictor, and Entropy Coder
FMT is not simply a new neural compression model. It co-designs three layers: the multiscale tree defines dependencies that can be parallelized, the predictor supplies values for each step, and parallel rANS lanes encode those values into a reversible bitstream. The representation and entropy-state schedule are therefore inseparable parts of the design.
The authors build a family of lossless configurations ranging from a rule-based codec with no neural network to codecs using large networks. The no-network variant demonstrates that part of the gain comes from the parallel format rather than model capacity. Larger models add conditional prediction and compression efficiency, but also introduce additional encoding cost, parameter memory, and startup latency.
All configurations target bit-exact lossless reconstruction, making compressed size and latency more relevant than perceptual metrics such as PSNR. The paper reports that the no-network FMT codec beats NVIDIA HTJ2K in both compressed size and speed in the authors' tests. A large-network variant is reported to run 9–61× faster than the learned codecs tested on the same A100 while producing equal or smaller files. The central contribution is therefore a reorganization of waiting, state updates, and parallel opportunities rather than a simple increase in inference FLOPs.
Engineering Trade-offs
- Fixed depth versus total work: Fixed sequential steps remove a dependency chain that grows with pixel count, but the system still processes every value. Peak memory, bandwidth requirements, and output buffers do not automatically become constant.
- GPU throughput versus CPU portability: Parallel rANS and batched prediction clearly favor GPUs. The main learned-codec comparisons use an A100, while CPU, browser, mobile, and edge-device behavior remains undisclosed.
- Compression gains versus model cost: A rule-based configuration reduces model dependency and prediction overhead but may leave visual priors unused. A large predictor can improve coding efficiency at the cost of encoding time, parameter memory, and cold-start overhead. Training requirements and encoder latency are not reported in the abstract.
- Parallel decoding versus bitstream correctness: rANS states are sensitive to symbol order. FMT preserves reversibility by carrying state through parallel lanes, but lane assignment, cross-step synchronization, and final bitstream serialization still require verification against the paper and implementation.
- New-format ecosystem cost: FMT cannot be assumed compatible with existing browsers, imaging libraries, thumbnail services, or storage pipelines. Container support, random access, progressive display, metadata specifications, and licensing status are not disclosed.
Reading the Benchmark Responsibly
Comparing learned codecs on the same A100 is more credible than reporting latency across different devices. Constraining file size also prevents a trivial comparison in which one method wins only by operating at a different compression ratio. The abstract still does not support a universal dominance claim.
Kodak is a standard benchmark, but it does not represent high-resolution photographs, training corpora, screenshots, synthetic images, or assets with transparency. The paper omits absolute compressed sizes, bits per pixel, end-to-end p50/p95 latency, throughput, batch size, and cold-start measurements. It also does not separate entropy decoding, neural prediction, file I/O, and post-processing.
The claim that no tested codec beats FMT on both size and speed applies only to the selected models, hardware, and rate operating points; it does not establish strict Pareto dominance at every bitrate. The no-network comparison with HTJ2K particularly requires checks of color transforms, predictor design, parallelism, metadata handling, and HTJ2K implementation quality. Independent reproduction should report compressed size across a full rate-distortion curve, end-to-end latency percentiles, GPU utilization, CPU fallback speed, peak memory, and bit-exact round-trip validation.
Deployment Guidance
- Prototype the format before integrating a model: Implement the FMT decoder, parallel rANS lanes, and reference bitstream, then verify pixel-exact reconstruction and cross-implementation consistency with random and real images.
- Use a broader evaluation matrix: Add high-resolution photographs, documents, charts, screenshots, and training-data slices to Kodak. Fix color space, bit depth, and metadata policy, while measuring compressed size, encode time, decode p50/p95, throughput, memory, and energy.
- Test CPU and GPU separately: GPU measurements should cover batch sizes, image dimensions, cold starts, and synchronization overhead. CPU performance determines whether the format can reach browsers, desktop software, or edge devices.
- Audit engineering interfaces: Verify random access, subtree-level decoding, streaming encoding, corruption recovery, container support, licensing, and integration with existing decoder libraries.
- Match configurations to workloads: The no-network codec is better suited to latency-sensitive archives, training pipelines, and batch processing. Large-predictor variants are more appropriate for offline storage where file size matters and GPU infrastructure is available.
FMT's strongest contribution is its shift from merely shrinking the compression model to redesigning data dependencies and entropy-state scheduling. If the reported results reproduce independently, the work could become a bridge between classical and learned lossless codecs. Until format support and complete benchmarks are available, it remains a promising codec-infrastructure research direction rather than a drop-in replacement for established image formats.
— END —Source: Hugging Face Daily Papers (2026-11-17)
Tags: #FMT #Lossless Image Compression #Learned Codecs #rANS #GPU Parallelism
Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.
Community Comments