Neural data compression has revolutionized how we store and transmit images, video, and 3D data. At its core, a learned codec maps high-dimensional data into a compact latent space, which is then converted into a binary stream using entropy coding. To minimize the bitrate, modern models use autoregressive context models to predict the probability distribution of each latent symbol based on its neighbors.
The intuition behind this is simple: if you know the values of surrounding pixels, you can guess the current pixel's value with high accuracy, reducing its entropy. However, this creates a fundamental conflict with modern hardware. Standard autoregressive models operate in a strict raster-scan order (top-to-bottom, left-to-right). Because decoding symbol $N$ requires the fully reconstructed value of symbol $N-1$, the entire process becomes strictly sequential. While GPUs excel at executing thousands of operations simultaneously, traditional entropy decoding forces them to sit idle, processing one pixel at a time.
To unlock the power of parallel hardware, researchers have developed techniques to break these serial dependency chains. The goal of parallel entropy decoding is to restructure context modeling so that large groups of symbols—or even entire data planes—can be decoded at the exact same time without severely degrading compression efficiency.
Spatial Partitioning and Checkerboard Contexts
How can we break a spatial chain of dependencies? The most intuitive solution is to split the latent grid into independent subsets.
In their work on the Checkerboard Context Model for Efficient Learned Image Compression, Dailan He et al. proposed a two-pass decoding strategy that reorganizes the latent space like a black-and-white chessboard. In the first pass, all "anchor" pixels (the black squares) are decoded simultaneously. Because they lack immediate spatial neighbors during this pass, they rely entirely on global side information (hyperpriors) to estimate their probabilities. In the second pass, the remaining "non-anchor" pixels (the white squares) are decoded in parallel, using the newly reconstructed anchors as their spatial context.
Raster Scan (Sequential) Checkerboard (Two-Pass Parallel)
[1][2][3][4] [A][ ][A][ ] <- Pass 1: Decode Anchors (A)
[5][6][7][8] [ ][A][ ][A] in parallel via hyperprior
[9]... [N][A][N][A] <- Pass 2: Decode Non-anchors (N)
[A][N][A][N] in parallel via anchor context
This simple shift from a pixel-by-pixel raster scan to a two-pass parallel strategy yields a massive throughput acceleration (up to 40x) on modern hardware. While the anchor pixels suffer a minor bitrate penalty due to the temporary lack of local context, the authors demonstrated that this trade-off heavily favors practical deployment.
This multi-pass philosophy has been widely adopted and extended. For instance, Yichen Qian et al. implemented a similar bidirectional context split in Entroformer: A Transformer-based Entropy Model for Learned Image Compression, while Wei Jiang showed in MLIC: Multi-Reference Entropy Model for Learned Image Compression that the representation loss of parallel spatial models can be recovered by stacking deeper non-linear attention layers.
Shifting Dimensions: Channel-Wise Autoregression
If spatial dependencies are inherently difficult to parallelize, we can look to a different dimension instead. Latent representations in deep networks are typically 3D tensors with height, width, and multiple channels.
Instead of scanning across space, we can perform autoregression across the channel dimension. In Transformer-based Transform Coding, Yinhao Zhu et al. demonstrated that the latent tensor can be divided into channel groups. Group 1 is decoded first using only global priors. Group 2 is then decoded using Group 1 as context, and so on. Crucially, because there are no intra-channel spatial dependencies, every single spatial location ($H \times W$) within a channel group can be decoded in parallel.
By shifting the sequential bottleneck from a massive spatial grid (e.g., $256 \times 256$ steps) to a handful of channel slices (e.g., 5 to 10 steps), the model achieves massive GPU parallelization. To maximize this effect, Tom Ryder et al. introduced a space-to-depth transformation in Split Hierarchical Variational Compression, downsampling spatial blocks into channels to allow high-throughput autoregressive modeling across channels rather than individual pixels. Similarly, Dailan He et al. combined spatial and channel-wise dependencies in PO-ELIC: Perception-Oriented Efficient Learned Image Coding to deliver high-fidelity perceptual results without latency penalties.
Hierarchical and Tree-Based Context
For data structures that are inherently non-grid-like, such as 3D LiDAR point clouds, spatial raster scans are completely impractical. Instead, these datasets are often organized into hierarchical trees, like octrees.
Traditional models decode octrees node-by-node, tracking the occupancy status of parent and sibling nodes sequentially. To break this bottleneck, Tingyu Fan et al. introduced a Multiscale Latent-Guided Entropy Model for LiDAR Point Cloud Compression. Instead of relying on immediate neighbors, they used hierarchical latent variables that summarize the spatial context of an entire layer at once. This mechanism allows all nodes within a specific depth of the octree to be decoded simultaneously, resulting in a decoding speedup of over 99.8%.
Similarly, Mingyue Cui et al. developed OctFormer: Efficient Octree-Based Transformer for Point Cloud Compression with Local Enhancement, which completely removes dependencies on the occupancy status of sibling nodes. By processing octree nodes within non-overlapping context windows, they traded a minimal amount of contextual information for a massive increase in processing speed. In the image domain, Wenhan Yang pursued a parallel philosophy in Coarse-to-Fine Hyper-Prior Modeling for Learned Image Compression, replacing pixel-wise serial context models with a multi-layer coarse-to-fine architecture that shifts the computational burden to a hierarchical structure processed simultaneously.
Geometric and Wavefront Parallelism
Another way to parallelize entropy decoding is to restrict the receptive field of the context model geometrically, rather than partitioning the data into discrete passes or layers.
If a context model's causal mask is designed such that a pixel only depends on its top and left neighbors, then all pixels along any given anti-diagonal line (from top-right to bottom-left) depend only on pixels that have already been decoded. In PILC: Practical Image Lossless Compression with an End-to-end GPU Oriented Neural Framework, Ning Kang et al. exploited this geometric property by restricting the receptive field of their auto-regressive model to a specific small geometry. This allowed the decoder to process entire anti-diagonals concurrently in a wavefront pattern, breaking the 100 MB/s speed barrier on GPUs.
Wavefront Processing (Anti-diagonals)
[1][2][3][4] Step 1: Decode [1]
[2][3][4][5] Step 2: Decode both [2]s in parallel
[3][4][5][6] Step 3: Decode all [3]s in parallel
[4][5][6][7] Step 4: Decode all [4]s in parallel
Kai Wang et al. extended this intuition to high bit-depth medical imaging in Learning Lossless Compression for High Bit-Depth Volumetric Medical Image, utilizing a parallel scanning order combined with masked convolutions to leverage analytical relationships between coding order and scanning angles, accelerating processing without losing predictive accuracy.
Bypassing Autoregression Entirely
The ultimate expression of parallel decoding is the complete elimination of autoregressive dependencies. If a model can generate highly accurate probability distributions using only side information or structural transformations, it can achieve perfect, single-pass parallelization.
Jerry Liu demonstrated this in Conditional Entropy Coding for Efficient Video Compression by utilizing a non-autoregressive entropy model that captures local and global structures entirely through a hyperprior mechanism. Similarly, Hao Cao et al. pushed this boundary further in Efficient Learned Image Compression without Entropy Coding by shifting the compression burden entirely to the latent space through statistical uniformity and spatial decorrelation. This allowed them to replace sequential entropy coding with parallelizable bit-packing, executing the entire decompression pipeline as a unified, GPU-native computation graph.
Key Foundational Work
A parallel context model for level information in CABAC (2011) — contributed 3 concept elements to this direction.
Accelerating Network Coding on Many-core GPUs and Multi-core CPUs (2009) — contributed 3 concept elements to this direction.
Network Coding on Heterogeneous Multi-Core Processors for Wireless Sensor Networks (2011) — contributed 2 concept elements to this direction.