Turbo-DDCM: Fast and Flexible Zero-Shot Diffusion-Based Image Compression

## Abstract

Abstract While zero-shot diffusion-based compression methods have seen significant progress in recent years, they remain notoriously slow and computationally demanding. This paper presents an efficient zero-shot diffusion-based compression method that runs substantially faster than existing methods, while maintaining performance that is on par with the state-of-the-art techniques.
Our method builds upon the recently proposed Denoising Diffusion Codebook Models (DDCMs) compression scheme. Specifically, DDCM compresses an image by sequentially choosing the diffusion noise vectors from reproducible random codebooks, guiding the denoiser’s output to reconstruct the target image.
We modify this framework with Turbo-DDCM , which efficiently combines a large number of noise vectors at each denoising step, thereby significantly reducing the number of required denoising operations.
This modification is also coupled with an improved encoding protocol. Furthermore, we introduce two flexible variants of Turbo-DDCM, a priority-aware variant that prioritizes user-specified regions and a distortion-controlled variant that compresses an image based on a target PSNR rather than a target BPP. Comprehensive experiments position Turbo-DDCM as a compelling, practical, and flexible image compression scheme. Code is available on our project’s website .

## 1 Introduction

The field of image compression has witnessed a shift towards neural-based approaches in recent years (balle2017endtoend; toderici2017resolutionimagecompressionrecurrent; li2020neuralimagecompressionexplanation), and more recently to methods that rely on diffusion models (sohl2015deep; ho2020denoising; song2020score). In particular, diffusion models have been utilized for image compression by training dedicated models (ghouse2023residual; NEURIPS2023_ccf6d8b4), by fine-tuning existing models (careil2024towards), or by using them in a zero-shot manner (theis2022lossy; elata2024zero; ohayon2025compressed; vonderfecht2025lossy).
In principle, zero-shot methods are appealing because they enable the same diffusion backbone to be shared across multiple tasks (such as compression, restoration, editing, generation, etc.), thereby allowing all tasks to benefit simultaneously from improvements to the shared backbone.
However, existing zero-shot diffusion compression methods remain impractical due to their high computational demands, which result in slow inference. Ranging from approximately 10 seconds (achieved using a custom CUDA kernel (vonderfecht2025lossy)) to several minutes (elata2024zero) for compressing and decompressing a single image, these slow inference times make zero-shot diffusion compression methods less compelling compared to training-based methods that operate much faster.

Figure: Figure 1: Turbo-DDCM: Our method provides reconstructions with equal or better fidelity compared to previous methods, while being much faster. At the same BPP and runtime, the priority-aware variant (bottom-right) better serves key regions of choice.
Refer to caption: x1.png

This work presents Turbo-DDCM, a fast and practical zero-shot diffusion-based compression method. It achieves a round-trip compression-decompression time of 1.5 seconds per image without custom hardware-specific optimizations, while maintaining competitive performance to state-of-the-art approaches. Our method extends Denoising Diffusion Codebook Model (DDCM) (ohayon2025compressed), a recently proposed zero-shot diffusion-based compression method that demonstrated state-of-the-art results. Specifically, DDCM compresses a target image by carefully *selecting* noise vectors during the generative diffusion process, in a manner that minimizes the denoising error between the target image and the denoiser’s output at each step.
Importantly, each noise vector is picked from a reproducible Gaussian codebook, implying that the final generated image can be efficiently stored/transmitted by storing/transmitting the indices of the selected noise vectors.
While such a simple compression mechanism works surprisingly well, it requires hundreds of denoising steps to achieve sufficient reconstruction quality, which results in an average round-trip compression-decompression time of 65 seconds. Our proposed Turbo-DDCM compression method accelerates this process by significantly reducing the required number of denoising steps to just a few dozen. In particular, Turbo-DDCM combines a large number of noise vectors at each DDCM step by solving a sparse least-squares optimization problem in closed form, leveraging the near-orthogonality of Gaussian codebook vectors in high-dimensional spaces.
While ohayon2025compressed proposed a seemingly similar approach that utilizes a matching pursuit (MP) strategy (mallat1993matching), their method relies on a greedy iterative process based on convex combinations and an exhaustive search. As a result, the scalability of this approach is limited due to runtime constraints. In contrast, our solution for combining codebook noise vectors is significantly faster and more computationally efficient.
Specifically, it achieves orders of magnitude faster runtime compared to the method proposed by ohayon2025compressed, while producing equivalent results (see App. [D](https://arxiv.org/html/2511.06424v1#A4) for theoretical justifications and empirical evaluations).
Indeed, we show that the high scalability of our noise combination strategy enables a 95% reduction in the number of required diffusion steps.
Beyond efficiency, we also propose a new bit-coding protocol for effective encoding of the indices of the selected noise vectors.
These contributions establish Turbo-DDCM as competitive with existing zero-shot methods in terms of reconstruction quality, while achieving dramatically lower runtime (see example in Fig. [1](https://arxiv.org/html/2511.06424v1#S1.F1)).

Finally, we introduce two flexible variants of Turbo-DDCM. The first supports priority-aware compression (li2023roibaseddeepimagecompression; Xu_2025_CVPR), which allows allocating more bits to arbitrarily shaped user-specified regions in the target image to improve reconstruction quality in those regions (see Fig. [1](https://arxiv.org/html/2511.06424v1#S1.F1) for an example). The second variant targets a user-specified PSNR rather than a fixed bitrate. This is useful since, at a fixed bitrate, Turbo-DDCM and alternative zero-shot methods yield highly variable distortion across images.
To the best of our knowledge, our work is the first to incorporate such capabilities into a zero-shot diffusion-based compression method.

To summarize, this paper introduces Turbo-DDCM – a novel and highly efficient diffusion-based image compression algorithm, with the following features:

- •
*Zero-shot:* Turbo-DDCM relies on a pre-trained latent diffusion generator, without any need for further training or fine-tuning. As such, the backbone diffusion model can be replaced flexibly to allow improved future versions.
- •
*Performance:* Turbo-DDCM has a competitive performance with the current state-of-the-art methods in terms of the rate-distortion-perception tradeoff.
- •
*Speed:* Turbo-DDCM is the fastest zero-shot method, achieving up to an order of magnitude speedup over the fastest existing approach. Our method operates without any custom hardware-specific acceleration, maintaining nearly constant runtime across bitrates.
This is achieved via a better noise sampling mechanism, which in turn allows using a shallower diffusion process. Coupled with a new bitstream protocol, performance is not compromised.
- •
*Perfect bitrate control:* Our method provides a predictable and constant bitrate across images, which can be finely controlled via a single hyperparameter across a wide range of bitrates.
- •
*Priority-aware:* We introduce a variant of Turbo-DDCM that enables enhanced reconstruction fidelity in user-selected regions of the image, with controllable prioritization levels.
- •
*Distortion control:* We present a distortion-geared Turbo-DDCM variant that targets a specific PSNR for each image (instead of target bitrate), addressing the variable distortion in zero-shot methods at fixed bitrate.

## 2 Related Work

##### Non-Zero-Shot Diffusion-based Image Compression.

Recent advances in diffusion-based compression have demonstrated impressive rate-distortion-perception performance by training models from scratch (NEURIPS2023_ccf6d8b4; ghouse2023residual; iwai2024controlling) or fine-tuning existing diffusion models  (korber2024perco; careil2024towards). More recently, several one-step methods (park2025diffosinglestepdiffusionimage; xue2025onestepdiffusionbasedimagecompression) have tried to bypass the computational cost of iterative denoising by directly learning a mapping from the latent code to the clean signal in a single reverse step. However, all these approaches share the drawback of requiring training or fine-tuning tailored for compression. In contrast, zero-shot methods preserve the diffusion model as a multi-purpose backbone, which can also serve for generation (ho2020denoising), restoration (kawar2022denoising; raphaeli2025silosolvinginverseproblems; man2025proxiesdistortionconsistencyapplications), editing (manor2024zeroshot; cohen2024slicedit), etc.

##### Zero-shot Diffusion-based Image Compression.

Rather than training models or fine-tuning existing models, some recent methods use pretrained diffusion models in a zero-shot manner for image compression. PSC (elata2024zero) and DiffC (theis2022lossy) harness ideas from compressed sensing (DonohoCompressedSensing) and reverse channel coding (RCC) (theis2022algorithmscommunicationsamples), respectively. DDCM (ohayon2025compressed) changes the standard DDPM process (ho2020denoising)
by sampling from a quantized Gaussian space, offering a simpler approach. However, all existing methods suffer from prohibitive computational demands, often requiring hundreds or even thousands of diffusion steps to compress a single image, making them unsuitable for practical usage. Recently, the RCC protocol used by DiffC was implemented on an optimized CUDA kernel (vonderfecht2025lossy), which alleviates much of the computational demands. However, this method remains limited by custom hardware-specific accelerations, large deviations from target bitrate across different input images, and substantial runtime variation across different compression bitrates. In contrast, our proposed method is the fastest by a wide margin, without custom hardware-dependent optimizations, nearly constant runtime across all bitrates and a constant bitrate between different images given the same target bitrate. At the same time, DiffC, DDCM, and our Turbo-DDCM share fundamental concepts in their underlying design, but extend it in different directions, as detailed in App. [H](https://arxiv.org/html/2511.06424v1#A8).

##### ROI (priority-aware) compression methods.

Region-of-interest (ROI) compression (li2023roibaseddeepimagecompression; jin2025customizableroibaseddeepimage) prioritizes user-specified regions of an image by allocating to them a larger portion of the bits, resulting in higher fidelity in those regions on the expense of others. This paradigm can be useful in medical imaging (srivastava2025regionbasedmedicalimage), video conference calls and more. Recently, it was demonstrated in diffusion-based compression (Xu_2025_CVPR). To the best of our knowledge, we are the first to apply ROI compression to a zero-shot diffusion method. We do so in a general way, enabling per-pixel prioritization, which we refer to as priority-aware compression.

## 3 Background

### 3.1 Denoising Diffusion Probabilistic Models (DDPM)

Diffusion models (sohl2015deep; ho2020denoising; song2020score) generate samples from a data distribution $p_{0}$ by learning to reverse a forward diffusion process. Specifically, for $t\in\{1,\ldots,T\}$, the forward process gradually corrupts the data ${\mathbf{x}}_{0}\sim p_{0}$ with noise via

$$ $\displaystyle{\mathbf{x}}_{t}=\sqrt{\alpha_{t}}{\mathbf{x}}_{t-1}+\sqrt{1-\alpha_{t}}{\bm{\upepsilon}}_{t},\quad{\bm{\upepsilon}}_{t}\sim\mathcal{N}({\bm{0}},{\bm{I}}),$ (1) $$

where $\alpha_{1},\ldots,\alpha_{T}>0$ are time-dependent constants controlling the signal-to-noise ratio.
In DDPM (ho2020denoising), the reverse diffusion process generates samples from the data distribution by gradually denoising a random noise sample ${\mathbf{x}}_{T}\sim\mathcal{N}({\bm{0}},{\bm{I}})$ via

$$ $\displaystyle{\mathbf{x}}_{t-1}$ $\displaystyle={\bm{\mu}}_{t}({\mathbf{x}}_{t})+\sigma_{t}{\mathbf{z}}_{t},\quad{\mathbf{z}}_{t}\sim\mathcal{N}({\bm{0}},{\bm{I}}),$ (2) $$

where $\sigma_{t}=\sqrt{1-\alpha_{t}}$, and ${\bm{\mu}}_{t}({\mathbf{x}}_{t})$ is the conditional mean of ${\mathbf{x}}_{t-1}$ given ${\mathbf{x}}_{t}$. ${\bm{\mu}}_{t}({\mathbf{x}}_{t})$ can be expressed in terms of the minimum mean-squared-error (MMSE) estimator $\hat{{\mathbf{x}}}_{0|t}$ of ${\mathbf{x}}_{0}$ given ${\mathbf{x}}_{t}$,

$$ $\displaystyle{\bm{\mu}}_{t}({\mathbf{x}}_{t})=\frac{\sqrt{\bar{\alpha}_{t-1}}\,(1-\alpha_{t})}{1-\bar{\alpha}_{t}}\hat{{\mathbf{x}}}_{0|t}+\frac{\sqrt{\alpha_{t}}\,(1-\bar{\alpha}_{t-1})}{1-\bar{\alpha}_{t}}{\mathbf{x}}_{t},$ (3) $$

where $\bar{\alpha}=\prod_{s=1}^{t}\alpha_{s}$.
The MMSE estimator $\hat{{\mathbf{x}}}_{0|t}$ plays a central role in the rest of this paper.

### 3.2 Denoising Diffusion Codebook Models (DDCM)

DDCM (ohayon2025compressed) modifies the reverse process of DDPM (eq. ([2](https://arxiv.org/html/2511.06424v1#S3.E2))) by replacing the random Gaussian noise sampling with a selection of noises from reproducible codebooks ${\bm{C}}_{t}$. Specifically, each codebook ${\bm{C}}_{t}$ is an ordered set filled with $K$ i.i.d. white Gaussian noise vectors, which we refer to as *atoms*,

$$ $\mathcal{C}_{t}=\left[{\bm{z}}_{t}^{(1)},{\bm{z}}_{t}^{(2)},\ldots,{\bm{z}}_{t}^{(K)}\right],\quad t=2,\ldots,T+1,$ (4) $$

where, as in DDPM, no noise is added at $t=1$.
The DDCM generation step then becomes

$$ ${\mathbf{x}}_{t-1}={\bm{\mu}}_{t}({\mathbf{x}}_{t})+\sigma_{t}{\bm{C}}_{t}({\textnormal{k}}_{t}),$ (5) $$

where ${\textnormal{k}}_{t}\stackrel{{\scriptstyle\text{i.i.d.}}}{{\sim}}\text{Unif}(\{1,\ldots,K\})$. This modification yields a discrete yet highly expressive generated distribution, as the number of possible distinct output samples grows exponentially with the number of diffusion steps.

The primary property of DDCM is its ability to act as a zero-shot image compression algorithm, achieved by creating all the codebooks once and keeping them constant for all subsequent applications of the model (e.g., by using a shared random seed).
Specifically, a target image is compressed by selecting, at each diffusion step, the fixed codebook atom that best matches the target image.
Formally, to compress a target image ${\mathbf{x}}_{0}$, ohayon2025compressed compute the denoising residual between ${\mathbf{x}}_{0}$ and the MMSE estimation $\hat{{\mathbf{x}}}_{0|t}$ at each timestep $t$, and select the codebook entry that maximizes the inner product with this residual:

$$ $k_{t}=\operatorname*{arg\,max}_{k\in\{1,...,K\}}\langle{\bm{C}}_{t}(k),{\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}\rangle,$ (6) $$

where $k_{t}$ is the selected codebook entry at timestep $t$.
This sampling process results in an ordered sequence of chosen indices $(k_{t})_{t=2}^{T}$, whose binary representation serves as the compressed form of the image. Decompression then follows eq. ([5](https://arxiv.org/html/2511.06424v1#S3.E5)), where instead of randomly sampling from the codebooks, the stored indices are re-selected deterministically. Consequently, the bits-per-pixel (BPP) of DDCM can easily be computed via

$$ $\text{BPP}_{\text{DDCM}}=\frac{(T-1)\lceil\log_{2}(K)\rceil}{\text{number of pixels}}.$ (7) $$

While this strategy leads to good results, it is practically limited only to the regime of extremely low bitrates. Indeed, even when using $T=1000$ diffusion steps and codebooks with $K=16{,}384$ atoms, the bitrate for a $768\times 768$ image is only about 0.024 BPP. Increasing $T$ applies the denoiser more times, which is computationally expensive, while increasing $K$ increases the bitrate logarithmically but makes searching for the correct noise much more demanding.
To enable higher bitrates, the authors propose a refinement strategy for noise selection based on matching pursuit (MP) (mallat1993matching). Specifically, at each step $t$, the chosen noise is constructed as a convex combination of $M$ elements from ${\bm{C}}_{t}$, selected greedily to maximize correlation with the residual ${\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|i}$ (as in eq. ([6](https://arxiv.org/html/2511.06424v1#S3.E6))). This combination involves $M-1$ quantized scalar coefficients, each drawn from a set of $2^{C}$ values within $[0,1]$. Transmitting the $M$ selected noise indices requires $\lceil\log_{2}(K)\rceil M$ bits per timestep, along with $C(M-1)$ bits for the quantized coefficients.
When using this approach, the BPP becomes

$$ $\text{BPP}_{\text{DDCM with MP}}=\frac{(T-1)\big(\lceil\log_{2}(K)\rceil M+C(M-1)\big)}{\text{number of pixels}}.$ (8) $$

This MP strategy widens the bitrate range of DDCM. In practice, however, it incurs extremely high runtime due to its iterative nature, as one MP process can take more than 0.1 seconds and must be performed after each diffusion step, resulting in a total cost multiplied by $T$. Moreover, due to its greedy design, increasing $M$ alone provides only limited gains in correlation with the residual; $C$ must also be increased, while runtime grows exponentially with $C$, which further limits scalability. See Apps. [C](https://arxiv.org/html/2511.06424v1#A3) and [D](https://arxiv.org/html/2511.06424v1#A4) for theoretical justifications and empirical demonstrations.

## 4 Method

We now turn to introduce Turbo-DDCM. This includes a new and highly efficient approach for combining *many* codebook atoms at each of DDCM’s denoising steps. Our approach yields additional advantages across multiple aspects of compression beyond the acceleration of DDCM’s matching pursuit. We complement our new noise construction method with a novel encoding protocol. An overview of our approach is shown in Fig. [2](https://arxiv.org/html/2511.06424v1#S4.F2).

Figure: Figure 2: Turbo-DDCM overview: Building on DDCM, we replace its random noise sampling with an effective and efficient closed-form selection rule that can quickly combine an arbitrary number of noise vectors, enabling significantly fewer diffusion steps. The selected indices are encoded using our new bit transmission protocol, which achieves substantially higher encoding efficiency than DDCM’s protocol. The decoder reconstructs the image by running the generative diffusion process while re-selecting the codebook noise vectors that correspond to the decoded indices. This results in a zero-shot compression method that is both highly efficient and competitive in performance.
Refer to caption: x2.png

### 4.1 Efficient Multi-Atom Selection

We approximate the residual vector ${\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}$ with a linear combination of exactly $M$ atoms having nonzero quantized coefficients from a fixed ordered set $\mathcal{V}$. Formally, our optimization problem for timestep $t$ is a constrained least squares of the form

$$ $\displaystyle{\mathbf{s}}_{t}^{*}=\operatorname*{arg\,min}_{{\mathbf{s}}_{t}\in\mathbb{R}^{K}}\left\lVert{\bm{C}}_{t}{\mathbf{s}}_{t}-({\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t})\right\rVert_{2}^{2}\quad\text{s.t.}\;\;\lVert{\mathbf{s}}_{t}\rVert_{0}=M,\;\;\forall i\,({\mathbf{s}}_{t})_{i}\in\mathcal{V}\cup\{0\},$ (9) $$

where $({\mathbf{s}}_{t})_{i}$ denotes the $i$-th entry of the vector ${\mathbf{s}}_{t}$.
Using the solution ${\mathbf{s}}_{t}^{*}$, we define

$$ ${\mathbf{z}}_{t}^{*}=\frac{{\bm{C}}_{t}{\mathbf{s}}^{*}_{t}}{\operatorname{std}({\bm{C}}_{t}{\mathbf{s}}^{*}_{t})}.$ (10) $$

Finally, the Turbo-DDCM sampling process is defined as

$$ ${\mathbf{x}}_{t-1}={\bm{\mu}}_{t}({\bm{x}}_{t})+\sigma_{t}{\mathbf{z}}^{*}_{t}.$ (11) $$

To solve the optimization problem in eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9)), we use an efficient closed-form solution. The key insight of our approach is that Gaussian random codebooks are nearly orthogonal in high-dimensional spaces (see App. [B](https://arxiv.org/html/2511.06424v1#A2) for how this approximate orthogonality affects performance). Under this assumption, the thresholding algorithm (elad2010book) provides a closed-form solution for sparse least squares (eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9)) without the quantization constraint):

$$ $\displaystyle({\mathbf{s}}_{t}^{*})_{i}=\begin{cases}({\mathbf{u}}_{t})_{i}/\|{\mathbf{z}}_{t}^{(i)}\|_{2},&i\in\operatorname{TopM}(|{\mathbf{u}}_{t}|)\\ 0,&\text{otherwise}\end{cases},\quad({\mathbf{u}}_{t})_{i}=\frac{\langle{\mathbf{z}}_{t}^{(i)},{\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}\rangle}{\|{\mathbf{z}}_{t}^{(i)}\|_{2}},\;i=1,\dots,K,$ (12) $$

where ${\mathbf{z}}_{t}^{(i)}$ is the $i$-th column of ${\bm{C}}_{t}$ and $\operatorname{TopM}(|{\mathbf{u}}|)$ denotes the indices of the $M$ largest entries of $|{\mathbf{u}}|$. We extend this solution to incorporate the quantization constraint. We then adapt it to our specific setting of Gaussian i.i.d. codebooks and our characteristic configurations which share all $\mathcal{V}=[-1,+1]$, resulting in the following algorithm:

$$ $\displaystyle({\mathbf{s}}_{t}^{*})_{i}=\begin{cases}\operatorname{sign}(({\mathbf{u}}_{t})_{i}),&i\in\operatorname{TopM}(|{\mathbf{u}}_{t}|)\\ 0,&\text{otherwise}\end{cases},\quad({\mathbf{u}}_{t})_{i}=\langle{\mathbf{z}}_{t}^{(i)},{\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}\rangle,\quad i=1,\dots,K.$ (13) $$

See App. [C](https://arxiv.org/html/2511.06424v1#A3) for the derivation and App. [E](https://arxiv.org/html/2511.06424v1#A5) for the rationale behind the chosen $\mathcal{V}$.

Our approach fundamentally differs from DDCM’s MP strategy in four key aspects, leading to enhanced capabilities and desirable properties.

##### Noise Construction Efficiency.

Our closed-form algorithm is orders of magnitude faster than DDCM MP, which relies on an iterative search with exhaustive evaluations. Consequently, we construct the noise at each diffusion step much more efficiently.

##### Number of Required Diffusion Steps.

Unlike DDCM, our method maintains a nearly constant runtime as $M$ increases (App. [D](https://arxiv.org/html/2511.06424v1#A4)). Thus, we can scale $M$ to hundreds, whereas DDCM MP is practically limited to very small values. This enables a major reduction in diffusion steps, as selecting many atoms per step leads to stronger residual estimations. Consequently, a few diffusion steps with strong estimations can replace many steps with weak ones. Overall, the number of diffusion steps is reduced by more than 95% (20 steps versus 500–1000) for comparable compression quality.

##### Possible Quantization Levels.

While DDCM’s MP is restricted to non-negative quantization levels due to its reliance on convex combinations, our approach allows both positive and negative coefficients. This effectively doubles the representational capacity, as allowing negative coefficients enables pointing in opposite directions, thereby increasing the number of directions in latent space available to approximate the residual and improving the solution to the optimization problem.

##### Hyperparameters.

Both DDCM and Turbo-DDCM rely on four hyperparameters that influence bitrate: $T$, $K$, $M$, and $C$. Controlling bitrate via $T$ increases expensive denoiser calls; varying $K$ slows optimization in both methods; and varying $C$ alone yields only marginal gains. In our thresholding-based approach, increasing $M$ enhances representational power with negligible runtime cost and allows fine-grained bitrate control. Consequently, Turbo-DDCM can adjust bitrate using $M$ alone, ensuring runtime stability across bitrates and avoiding inefficient hyperparameter combinations. DDCM, however, cannot benefit from increasing $M$ in isolation and must simultaneously increase $C$. As it is not computationally efficient in both, it must also increase $K$ and $T$, resulting in significant runtime variation across bitrates. Moreover, DDCM is highly sensitive to inefficient hyperparameter combinations, which can further degrade performance. Detailed justifications and demonstrations are provided in Apps. [C](https://arxiv.org/html/2511.06424v1#A3), [D](https://arxiv.org/html/2511.06424v1#A4) and [E](https://arxiv.org/html/2511.06424v1#A5).

Due to the large reduction in $T$ described above, we replace the synthesized noise ${\mathbf{z}}_{t}^{*}$ in the final steps with DDIM sampling to improve perceptual quality at low bitrates. The number of DDIM steps, $N$, is determined heuristically and decreases with increasing bitrate. Specifically, for a $T$-step scheduler, the encoder transmits ${\mathbf{z}}_{t}^{*}$ for the first $T-N$ steps, which the decoder reconstructs, followed by $N$ DDIM steps executed only at the decoder. See App. [A](https://arxiv.org/html/2511.06424v1#A1) for exact details.

### 4.2 Efficient Bit Protocol for Large-M Combinations

When large $M$ values are employed, using the DDCM’s bit protocol leads to poor compression due to redundancies. Specifically, DDCM encodes atom selections with $\lceil\log_{2}(K)\rceil M$ bits per diffusion step, preserving the order in which the atoms were selected, which is crucial for the noise constriction on the decoder. However, in our thresholding-based approach, atom ordering is semantically meaningless and only identity matters. Thus, a naive encoding of $M$ indices creates $M!$ equivalent representations per step, yielding $(M!)^{T-1}$ identical compressed representations. For extremely modest parameters of $M=5$ and $T=20$, this results in $120^{19}\approx 2^{131}$ equivalent representations, underscoring the need for a more efficient encoding protocol.

Each diffusion step requires communicating a combination of $M$ indices from a codebook of size $K$ (without repetition and order-invariant) along with quantized coefficients ($C$ bits each). The number of distinct choices is $\binom{K}{M}\cdot(2^{C})^{M}$, requiring

$$ $\left\lceil\log_{2}\left(\binom{K}{M}\cdot(2^{C})^{M}\right)\right\rceil=\left\lceil\log_{2}\binom{K}{M}\right\rceil+MC$ (14) $$

bits per step. This gives the worst-case lower bound on the bits needed to encode this information.

We propose an encoding protocol that achieves this bound. Our protocol transmits the lexicographical index of the selected $M$-atom combination from within the set $\{1,\ldots,\binom{K}{M}\}$ of possible indices, followed by the selected $M$ quantized coefficients in canonical order. This approach eliminates the observed factorial redundancy while transmitting effectively the same information. Consequently, Turbo-DDCM’s BPP is

$$ $\text{BPP}_{\text{Turbo-DDCM}}=\frac{(T-N-1)\left(\left\lceil\log_{2}\binom{K}{M}\right\rceil+MC\right)}{\text{number of pixels}}.$ (15) $$

As shown in App. [F](https://arxiv.org/html/2511.06424v1#A6), our protocol reduces BPP by $\sim 40\%$ for typical Turbo-DDCM configurations.

## 5 Experiments

Figure: Figure 3: Qualitative results: The presented images are taken from the Kodak24 ($512\times 512$) dataset. Our method produces highly realistic reconstructions while achieving a speedup ranging from $3\times$ to an order of magnitude compared to previous approaches, depending on the bitrate.
Refer to caption: x3.png

Figure: Figure 4: Quantitative evaluation: Comparison with zero-shot (top two rows) and other (bottom row) methods, reporting distortion (PSNR, LPIPS), perceptual quality (FID), and runtime (round-trip compression–decompression in seconds). PSC’s runtime is omitted due to its extreme complexity (>300 s/image). Turbo-DDCM achieves superior or competitive results against all zero-shot methods while being substantially faster. Compared to other methods, Turbo-DDCM provides the best perceptual quality. Note that all zero-shot methods and PerCo (SD) operate in the latent space of SD 2.1, whose encoder–decoder imposes a distortion bound; we report this bound by just passing the images through this encoder–decoder.
Refer to caption: x4.png

We evaluate our compression method on the Kodak24 (franzen1999kodak) and DIV2K (agustsson2017ntire) datasets, center-cropping to $512\times 512$ and $768\times 768$, respectively. We compare to all existing zero-shot diffusion-based methods known to us: PSC (elata2024zero), DDCM (ohayon2025compressed), and DiffC (theis2022lossy), using the custom CUDA kernel implementation of DiffC (vonderfecht2025lossy). Additionally, we compare to non-neural, fine-tuning-based and training-based approaches, including BPG (bpg), PerCo (SD) (korber2024perco; careil2024towards), ILLM (muckley2023improving) and two CRDR (iwai2024controlling) configurations. All zero-shot methods use the same pre-trained diffusion models unconditionally: SD 2.1 Base for $512\times 512$ images and SD 2.1 for $768\times 768$ images. For Turbo-DDCM we use $T=20$, $K=16{,}384$, $C=1$ and vary $M$ from 5 to 700 to control the bitrate. Distortion is measured using PSNR and LPIPS (zhang2018perceptual), while perceptual quality is evaluated with FID (bińkowski2018demystifying), computed on $64\times 64$ patches following mentzer2020high. Runtime is measured based on process time for a round-trip compression-decompression on an NVIDIA A40 GPU.

##### Compression Quality.

As shown in Figs. [3](https://arxiv.org/html/2511.06424v1#S5.F3) and [4](https://arxiv.org/html/2511.06424v1#S5.F4), Turbo-DDCM achieves competitive results against both zero-shot and non-zero-shot methods. Among zero-shot approaches, it surpasses PSC in distortion and perception while matching DDCM’s performance. At low bitrates, DiffC yields better perceptual quality than Turbo-DDCM with equal distortion. At high bitrates DiffC attains lower distortion but Turbo-DDCM offers superior, and sometimes comparable, perceptual quality. Compared to other methods, Turbo-DDCM dominates prior work on the rate-distortion-perception tradeoff (pmlr-v97-blau19a) for low bitrates, offering the best perception and better distortion than PerCo (SD) which is perceptually-oriented as well. However, for high bitrates our method under-performs. When using a latent diffusion model such as SD, compression is applied to the latent representation rather than the image itself. Since the encoder–decoder already introduces distortion, the maximum attainable quality of any latent-based method is bounded by this reconstruction error, forming a natural upper limit (korber2024perco; elata2024zero). Accordingly, Fig. [4](https://arxiv.org/html/2511.06424v1#S5.F4) reports this bound. See App. [A](https://arxiv.org/html/2511.06424v1#A1) for additional evaluations.

##### Runtime Performance.

As shown in Figs. [3](https://arxiv.org/html/2511.06424v1#S5.F3) and [4](https://arxiv.org/html/2511.06424v1#S5.F4), Turbo-DDCM achieves state-of-the-art runtime by a significant margin. It outperforms DDCM by more than an order of magnitude, achieving over $40\times$ speedup at high bitrates. Turbo-DDCM also outperforms DiffC, with a $3\times$ speedup at low bitrates and an order of magnitude at high bitrates. Importantly, this performance advantage is achieved even though DiffC employs a custom CUDA kernel. Furthermore, our method maintains nearly constant runtime across bitrates, unlike competing methods. As runtime might be implementation-dependent, we also compare the number of neural-function-evaluations (NFEs), which correspond to denoiser activations in this case. Even though NFE is implementation independent, it is imperfect, since it ignores operations performed between denoiser activations, which might also be computationally demanding. Nevertheless, the trends and differences in NFEs closely follow those observed for runtime, as detailed in App. [A](https://arxiv.org/html/2511.06424v1#A1), along with additional evaluations.

## 6 Turbo-DDCM Variants

Figure: Figure 5: Qualitative results of the priority-aware (PA) variant: Regular methods fail to reconstruct key regions, whereas our PA variant reconstructs them faithfully according to the prioritization mask. In the second row, the first two lines of the sign that are highly prioritized, are fully reconstructed, while the third line, medium prioritized, is only partially reconstructed. These results are better viewed when zoomed in.
Refer to caption: x6.png

While traditional diffusion-based methods allocate bits uniformly across the image, some applications (e.g. medical imaging) benefit from prioritizing important regions. This paradigm, commonly referred to as ROI (region-of-interest) compression (li2023roibaseddeepimagecompression; srivastava2025regionbasedmedicalimage), improves fidelity in specified areas at the expense of others by non-uniform bit allocation. We introduce a variant of Turbo-DDCM that supports ROI compression through per-pixel prioritization, which we term priority-aware compression.

Our adaptation is based on a latent priority mask ${\bm{w}}\in\mathbb{R}_{+}^{d}$, where each entry specifies the relative weight of the corresponding latent coordinate, obtained by down-sampling a pixel-space prioritization map. We then extend the optimization problem in eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9)) to

$$ $\displaystyle{\mathbf{s}}_{t}^{*}=\operatorname*{arg\,min}_{{\mathbf{s}}_{t}\in\mathbb{R}^{K}}\;\lVert{\bm{C}}_{t}{\mathbf{s}}_{t}-{\bm{w}}\odot({\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t})\rVert_{2}^{2}\quad\text{s.t.}\quad\lVert{\mathbf{s}}_{t}\rVert_{0}=M,\;\;\forall i\,({\mathbf{s}}_{t})_{i}\in\mathcal{V}\cup\{0\}.$ (16) $$

Here, the residual vector (${\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}$) is weighted by ${\bm{w}}$, scaling each error according to its corresponding pixel priority. The $M$ codebook atoms and their quantized coefficients are then chosen accordingly. Importantly, ${\bm{w}}$ is not transmitted to the decoder, leaving both the encoding protocol and the BPP unchanged. Additionally, this modification has a negligible impact on runtime.

We evaluate our variant on the Kodak24 ($512\times 512$) dataset and compare to the other zero-shot methods, including the baseline Turbo-DDCM. Figure [5](https://arxiv.org/html/2511.06424v1#S6.F5) shows that, unlike regular zero-shot methods, our priority-aware variant successfully reconstructs regions that would otherwise be poorly recovered, adapting fidelity according to the prioritization mask while keeping the same BPP. Additional details and results can be found in App. [A](https://arxiv.org/html/2511.06424v1#A1).

Our second variant of Turbo-DDCM addresses the significant distortion variation across images at fixed target bitrates – see Fig. [S15](https://arxiv.org/html/2511.06424v1#A7.F15). We present a simple and efficient method to address this problem, substantially reducing this variation while targeting a given distortion level.
See App. [G](https://arxiv.org/html/2511.06424v1#A7) for more details on this variant of the algorithm.

## 7 Conclusion and Discussion

This paper introduces Turbo-DDCM, an efficient and flexible zero-shot diffusion-based compression method. It achieves state-of-the-art runtime, reducing round-trip compression-decompression time by up to an order of magnitude compared to the fastest prior zero-shot method, while maintaining competitive compression quality compared to state-of-the-art techniques. It also offers favorable properties, such as a constant bitrate across images for a given target bitrate.
Moreover, we extend Turbo-DDCM with two variants: the first supports priority-aware compression for spatially-varying fidelity, and the second is a distortion-targeted mode that fixes PSNR instead of bitrate.

While our method significantly advances zero-shot compression speed, training-based methods
can achieve similar reconstruction quality in a single forward pass. A one-step zero-shot method could provide significant additional speedup while preserving zero-shot flexibility. Moreover, some zero-shot methods demonstrate superior rate-distortion-perception trade-off compared to our method,
suggesting potential room for improvement. Finally, establishing a comprehensive theory for DDCM-based compression remains an open problem that could guide future improvements.

#### Acknowledgments

This research was partially supported by the Israel Science Foundation (ISF) under Grants 951/24, 409/24, and 2318/22, as well as by the Council for Higher Education– Planning and Budgeting Committee. G.O. gratefully acknowledges the Viterbi Fellowship from the Faculty of Electrical and Computer Engineering at the Technion.

## Appendix

## Appendix A Experimental Configurations and Additional Evaluations

All distortion and perceptual quality metrics are computed using Torch Metrics, which is built on Torch Fidelity (obukhov2020torchfidelity).

### A.1 Compared Configurations

The following outlines the experimental configurations used for the evaluations in Section [5](https://arxiv.org/html/2511.06424v1#S5).

##### Zero-Shot Methods.

For all methods we use Stable Diffusion 2.1 Base for $512\times 512$ images and Stable Diffusion 2.1 for $768\times 768$ images, based on the official [stabilityai/stable-diffusion-2-1-base](https://huggingface.co/stabilityai/stable-diffusion-2-1-base)
and [stabilityai/stable-diffusion-2-1](https://huggingface.co/stabilityai/stable-diffusion-2-1)
checkpoints from Hugging Face, using float16 precision.
The remaining hyperparameters are determined as follows:

- •
for Turbo-DDCM we use $T=20$, $K=16{,}384$, $C=1$ and the following list of $M$ values to control bitrate:
$\displaystyle[5,8,12,17,23,30,37,45,55,65,85,105,125,145,200,275,350,500,700].$
(S1)
To determine $N$, we initially assume $N=0$ and calculate a preliminary value $BPP_{0}$ using eq. ([15](https://arxiv.org/html/2511.06424v1#S4.E15)). We then set $N$ as follows:
$\displaystyle N=\begin{cases}5,&BPP_{0}\in(0,\,0.016],\\
4,&BPP_{0}\in(0.016,\,0.025],\\
3,&BPP_{0}\in(0.025,\,0.043],\\
2,&BPP_{0}\in(0.043,\,0.062],\\
1,&BPP_{0}\in(0.062,\,0.086],\\
0,&BPP_{0}>0.086.\end{cases}$
(S2)
See App. [E](https://arxiv.org/html/2511.06424v1#A5) for the rationale behind the chosen hyperparameters.
- •
For PSC we use the hyperparameters that the author described (elata2024zero), setting the number of measurements to $12\cdot 2^{i}$ for $i=0,...,8$.
- •
For DDCM we use $T\in\{500,1000\}$, $K\in\{64,128,\ldots,8192\}$, $M\in\{1,2,...,6\}$ and $C\in\{2,3\}$ which aligns with the spirit of the hyperparameter configurations described by the authors (ohayon2025compressed).
- •
For DiffC we use the schedulers, $D_{KL}$ values and reconstruction timesteps suggested by the authors (vonderfecht2025lossy).

##### Non-Zero-Shot Methods.

The hyperparameters for the non-zero-shot methods are as follows:

- •
For CRDR-R and CRDR-D we use the quality factors of $\{0,1,2,3,4\}$, where CRDR-D uses $\beta=0$ and CRDR-R uses $\beta=3.84$, as recommended by the authors (iwai2024controlling).
- •
For ILLM we use the MS-ILLM pre-trained models available in the [Official GitHub repository](https://github.com/facebookresearch/NeuralCompression/tree/main/projects/illm). We use msillm_quality_X for X = 2,3 and msillm_quality_vloY for Y = 1,2.
- •
For BPG we use quality factors $q\in\{51,50,48,46,42,40,29,36,34,32\}$.
- •
For PerCo (SD) we use the three publicly available Stabe Diffusion 2.1 fine-tuned checkpoints from the [Official GitHub repository](https://github.com/Nikolai10/PerCo), with the default hyperparameters.

### A.2 Additional Efficiency Evaluation

As discussed in Section [5](https://arxiv.org/html/2511.06424v1#S5), runtime measurements can be biased by implementation details. We therefore compare the number of neural function evaluations (NFEs) (Fig. [S1](https://arxiv.org/html/2511.06424v1#A1.F1)), corresponding to denoiser activations, across the zero-shot methods. While NFEs are implementation-independent, they do not capture costs from other components, such as the RCC in DiffC, the MP process in DDCM and the thresholding-based process in Turbo-DDCM. The alignment between NFEs and runtime trends suggest that our efficiency is not attributable to implementation details.

Figure: Figure S1: Round-Trip compression-decompression NFEs comparison: Our method maintains its advantage over others, with margins similar to those observed in runtime.
Refer to caption: x7.png

### A.3 Additional Reconstruction Quality Evaluation

Figs. [S2](https://arxiv.org/html/2511.06424v1#A1.F2) and [S3](https://arxiv.org/html/2511.06424v1#A1.F3) provide additional qualitative comparisons on the Kodak24 ($512\times 512$) and DIV2K ($512\times 512$) datasets, against both zero-shot and non-zero-shot methods.
Fig. [S4](https://arxiv.org/html/2511.06424v1#A1.F4) presents additional quantitative results on the DIV2K ($512\times 512$) dataset, compared to non-zero-shot methods.

Figure: Figure S2: Qualitative results compared to zero-shot methods: The images are taken from the Kodak24 dataset, center-cropped to $512\times 512$ pixels. Our compression method generates highly realistic reconstructions, matching or surpassing prior approaches in fidelity to the original images, while consistently offering significant runtime improvements.
Refer to caption: x8.png

Figure: Figure S3: Qualitative results compared to non-zero-shot methods: The images are taken from the Kodak24 and DIV2K datasets, center-cropped to $512\times 512$ pixels. Our compression method produces highly realistic reconstructions and preserves better fidelity to the original images compared to previous methods.
Refer to caption: x9.png

Figure: Figure S4: Quantitative evaluation compared to non-zero-shot methods: Our method achieves the highest perceptual quality among the compared approaches, with superior distortion compared to PerCo (SD) which is perceptually-oriented as well. Note that both our method and PerCo (SD) operate in the latent space of Stable Diffusion 2.1, whose encoder–decoder imposes a distortion bound. Accordingly, we report the distortion obtained by just passing the images through this encoder–decoder.
Refer to caption: x10.png

### A.4 Additional Evaluations for the Priority-Aware Variant

Figure [S5](https://arxiv.org/html/2511.06424v1#A1.F5) illustrates how the priority-aware variant improves the fidelity of prioritized regions as the prioritization level increases. Figures [S6](https://arxiv.org/html/2511.06424v1#A1.F6) and [S7](https://arxiv.org/html/2511.06424v1#A1.F7) highlight the advantage of priority-aware compression in reconstructing complex image regions at extremely low bitrates. Depending on the prioritization level, our method successfully reconstructs these regions, while other methods fail to reconstruct them at all.

Figure: Figure S5: Priority-Aware results: $p$ stands for the prioritization level, such that the values in ${\bm{w}}$ (Section [6](https://arxiv.org/html/2511.06424v1#S6)) are 1 for the deprioritized pixels and $1+p$ for the prioritized ones. Reconstruction of the prioritized regions shows better fidelity to the original image as the prioritization level increases.
Refer to caption: x11.png

Figure: Figure S6: Priority-Aware results: With our priority-aware (PA) variant, specific objects in the image can be reconstructed at extremely low BPPs, with fidelity depending on the prioritization level. These objects are not reconstructed by other methods at the same BPP.
Refer to caption: x12.png

Figure: Figure S7: Priority-Aware results: With our priority-aware (PA) variant, specific objects in the image can be reconstructed at extremely low BPPs, with fidelity depending on the prioritization level. These objects are barely reconstructed, if at all, by other methods at the same BPP.
Refer to caption: x14.png

## Appendix B Codebooks Near-Orthogonality

As described in Section [4](https://arxiv.org/html/2511.06424v1#S4), we assume that the codebook in each diffusion step ${\bm{C}}_{t}$ is orthogonal to build on the efficient and closed-form thresholding algorithm. However, since the codebook consists of i.i.d. Gaussian noise vectors, they are not necessarily orthogonal. Thus, in this short appendix, we evaluate how much this approximation degrades the quality of the solution. We do so by applying Gram-Schmidt (GS) orthogonalization to all the codebooks and comparing the results to the baseline, which does not use GS. Notably, if GS is performed in the encoder, it should be done in the decoder as well. On the one hand, GS requires substantial computation, since we may use large codebooks with more than $K=16k$ atoms, this results in codebooks larger than $16k\times 16k$ in the SD 2.1 Base latent space. On the other hand, GS makes the orthogonality assumption valid and might yield better solutions that could enable better compression capabilities.

Figure [S8](https://arxiv.org/html/2511.06424v1#A2.F8) shows that for our chosen codebook size of $K=16{,}384$ atoms, the distortion with and without GS is equivalent. Additional justification for this choice of $K$ is provided in App. [E](https://arxiv.org/html/2511.06424v1#A5).

Figure: Figure S8: Effect of the orthogonality assumption: The codebook size used is $16k\times 16k$. Applying Gram-Schmidt orthogonalization to the codebook does not improve PSNR compared to the unmodified version, which does not apply Gram-Schmidt.
Refer to caption: x16.png

## Appendix C Thresholding-based Strategy Correctness

As explained in Section [4](https://arxiv.org/html/2511.06424v1#S4), Turbo-DDCM employs a fundamentally different approach to combining codebook atoms compared to DDCM. Our method builds on the thresholding algorithm (elad2010book), which solves sparse least squares, with modifications tailored to our problem, such as the quantization constraint. To present our considerations clearly, we derive the solution from scratch. We also compare our approach to DDCM MP.

### C.1 Problem Setup

Inputs.
For diffusion timestep $t$:

- •
Original image: ${\mathbf{x}}_{0}$
- •
Prediction of the original image: $\hat{{\mathbf{x}}}_{0|t}$
- •
Codebook of i.i.d. Gaussian atoms: ${\bm{C}}_{t}\in\mathbb{R}^{d\times K}$, where $d$ is the dimensionality and $K$ is the codebook size
- •
Sparsity parameter: $M$
- •
Quantization ordered set: $\mathcal{V}=[q_{0},...,q_{2^{C}}]$ (communication cost is $\log_{2}|\mathcal{V}|=C$ bits).

We define the residual at timestep $t$ as

$$ ${\bm{r}}_{t}:={\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}.$ (S3) $$

Objective: Find a linear combination of codebook atoms that best approximates the residual, subject to a sparsity constraint and a quantization constraint. Formally, the optimization problem is

$$ $\displaystyle{\mathbf{s}}_{t}^{*}=\operatorname*{arg\,min}_{{\mathbf{s}}_{t}\in\mathbb{R}^{K}}\left\lVert{\bm{C}}_{t}{\mathbf{s}}_{t}-{\mathbf{r}}_{t}\right\rVert_{2}^{2}\quad\text{s.t.}\;\;\lVert{\mathbf{s}}_{t}\rVert_{0}=M,\;\;\forall i\,({\mathbf{s}}_{t})_{i}\in\mathcal{V}\cup\{0\}.$ (S4) $$

Assumption: ${\bm{C}}_{t}$ is nearly-orthogonal. See App. [B](https://arxiv.org/html/2511.06424v1#A2) for the impact of this assumption.

### C.2 Approximated Closed-Form Derivation

Let $\text{proj}_{t}$ be the orthogonal projection of ${\bm{r}}_{t}$ onto the column space of ${\bm{C}}_{t}$. By the Pythagorean theorem,

$$ $\|{\bm{C}}_{t}{\mathbf{s}}_{t}-{\bm{r}}_{t}\|_{2}^{2}=\|{\bm{C}}_{t}{\mathbf{s}}_{t}-\text{proj}_{t}\|_{2}^{2}+\|\text{proj}_{t}-{\bm{r}}_{t}\|_{2}^{2}.$ (S5) $$

Since $\|\text{proj}_{t}-{\mathbf{r}}_{t}\|_{2}^{2}$ is independent of ${\mathbf{s}}_{t}$, the objective reduces to

$$ $\operatorname*{arg\,min}_{{\mathbf{s}}_{t}}\|{\bm{C}}_{t}{\mathbf{s}}_{t}-\text{proj}_{t}\|_{2}^{2},$ (S6) $$

subject to the same constraints.

Because $\text{proj}_{t}$ lies in the column space of ${\bm{C}}_{t}$, there exists ${\mathbf{s}}_{proj}$ such that $\text{proj}_{t}={\bm{C}}_{t}{\mathbf{s}}_{proj}$, yielding

$$ $\operatorname*{arg\,min}_{{\mathbf{s}}_{t}}\|{\bm{C}}_{t}({\mathbf{s}}_{t}-{\mathbf{s}}_{\text{proj}})\|_{2}^{2}.$ (S7) $$

Under the near-orthogonality assumption

$$ ${\mathbf{s}}_{\text{proj},i}\approx\frac{\langle{\bm{z}}_{t}^{(i)},{\bm{r}}_{t}\rangle}{\|{\bm{z}}_{t}^{(i)}\|_{2}^{2}},$ (S8) $$

where ${\bm{z}}^{(i)}_{t}$ is the $i$-th column of ${\bm{C}}_{t}$. Since the atoms are high-dimensional i.i.d. Gaussian vectors, their norms are approximately equal. Hence, the optimization is approximated by

$$ $\operatorname*{arg\,min}_{{\mathbf{s}}_{t}}\left\lVert\sum^{K}_{i=1}({\mathbf{s}}_{t,i}-\langle{\bm{z}}_{t}^{(i)},{\mathbf{r}}_{t}\rangle){\bm{z}}_{i}\right\rVert_{2}^{2}.$ (S9) $$

Using the near-orthogonality and the Pythagorean theorem the problem reduces to

$$ $\operatorname*{arg\,min}_{{\mathbf{s}}_{t}}\sum^{K}_{i=1}({\mathbf{s}}_{t,i}-\langle{\bm{z}}_{t}^{(i)},{\mathbf{r}}_{t}\rangle)^{2}\|{\bm{z}}_{i}\|_{2}^{2}\approx\operatorname*{arg\,min}_{{\mathbf{s}}_{t}}\sum^{K}_{i=1}({\mathbf{s}}_{t,i}-\langle{\bm{z}}_{t}^{(i)},{\mathbf{r}}_{t}\rangle)^{2}.$ (S10) $$

##### Sparsity only constraint.

If we ignore quantization constraint and enforce only the sparsity constraint, then for any support
$S\subset\{1,\dots,K\}$ with $|S|=M$ the optimal coefficients are

$$ $\displaystyle{\mathbf{s}}_{t,i}=\begin{cases}\alpha_{i}:=\langle{\bm{z}}_{t}^{(i)},{\bm{r}}_{t}\rangle,&i\in S,\[6.0pt] 0,&i\notin S.\end{cases}$ (S11) $$

The corresponding error is

$$ $\displaystyle E(S)=\sum_{i\notin S}\alpha_{i}^{2}.$ (S12) $$

Thus, the best support is obtained by selecting the $M$ indices with the largest values of $\alpha_{i}^{2}$.

##### Adding the quantization constraint.

Now coefficients must lie in the finite set $\mathcal{V}$. For a fixed index $i$, the best quantized value is the nearest element of $\mathcal{V}$ to $\alpha_{i}$. Thus, we define

$$ $\displaystyle q_{i}^{\star}\;:=\;\arg\min_{q\in\mathcal{V}}|q-\alpha_{i}|.$ (S13) $$

If we select index $i$ and quantize to $q_{i}^{\star}$, the error contribution of index $i$ becomes

$$ $\displaystyle E_{i}^{\text{quant}}\;=\;(q_{i}^{\star}-\alpha_{i})^{2}.$ (S14) $$

Compared to leaving index $i$ out (which yields error of $\alpha_{i}^{2}$), the net reduction in error by selecting-and-quantizing $i$ is

$$ $\displaystyle\Delta_{i}\;=\;\alpha_{i}^{2}-(q_{i}^{\star}-\alpha_{i})^{2}.$ (S15) $$

As a result, the best support in that case is obtained by selecting the $M$ indices with the largest values of $(\alpha_{i}^{2}-(q_{i}^{\star}-\alpha_{i})^{2})$.

##### Turbo-DDCM Characteristic Quantization Levels.

In Turbo-DDCM we use the quantization set $\mathcal{V}=[-1,1]$, corresponding to $C=1$ (see App. [E](https://arxiv.org/html/2511.06424v1#A5) for the rationale). Thus, for each atom, the nearest quantized value is $q_{i}^{\star}=\operatorname{sign}(\alpha_{i})$, yielding a net error reduction

$$ $\displaystyle\Delta_{i}$ $\displaystyle=2|\alpha_{i}|-1=2|\langle{\bm{z}}_{t}^{(i)},{\bm{r}}_{t}\rangle|-1.$ (S16) $$

Thus, the support can be chosen simply by selecting the $M$ indices with the largest $|\langle{\bm{z}}_{t}^{(i)},{\bm{r}}_{t}\rangle|$ values with correspondence quantized coefficients of $\operatorname{sign}(\langle{\bm{z}}_{t}^{(i)},{\bm{r}}_{t}\rangle)$.

### C.3 Approximation Quality and Hyperparameter: Turbo-DDCM vs. DDCM MP

Both DDCM MP and our thresholding-based strategy aim to combine codebook atoms to improve the approximation of the residual vector. Although their approaches fundamentally differ, their underlying goal is the same. This becomes evident when evaluating the final constructed noise ${\mathbf{z}}^{*}$ from each method within their
respective optimization problems for $M=1$, assuming ${\mathbf{z}}^{*}$ is the selected noise. In DDCM, the objective reduces to maximizing the inner product between the noise and the residual vector, while in Turbo-DDCM it reduces to minimizing the $L_{2}$ norm of their difference (eq. ([6](https://arxiv.org/html/2511.06424v1#S3.E6)) and eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9))). Importantly, $\lVert{\mathbf{z}}^{*}\rVert_{2}$ is approximately constant across both methods, due to normalization to unit standard deviation and the approximate zero mean of ${\mathbf{z}}^{*}$. Under this condition, the objectives are closely related:

$$ $\displaystyle\operatorname*{arg\,min}_{{\mathbf{z}}^{*}}\|{\mathbf{z}}^{*}-{\bm{r}}\|_{2}^{2}$ $\displaystyle=\operatorname*{arg\,min}_{{\mathbf{z}}^{*}}\big(\|{\mathbf{z}}^{*}\|_{2}^{2}+\|{\bm{r}}\|_{2}^{2}-2\langle{\mathbf{z}}^{*},{\bm{r}}\rangle\big)$ (S17) $\displaystyle\approx\operatorname*{arg\,max}_{{\mathbf{z}}^{*}}\langle{\mathbf{z}}^{*},{\bm{r}}\rangle.$ (S18) $$

Moreover, since $\langle{\mathbf{z}}^{*},{\bm{r}}\rangle=\|{\mathbf{z}}^{*}\|_{2}\|{\bm{r}}\|_{2}\cos\theta$, with $\theta\in[0,\pi]$ denoting the unsigned angle between the two vectors, we obtain

$$ $\displaystyle\operatorname*{arg\,max}_{{\mathbf{z}}^{*}}\langle{\mathbf{z}}^{*},{\bm{r}}\rangle$ $\displaystyle=\operatorname*{arg\,max}_{{\mathbf{z}}^{*}}\|{\mathbf{z}}^{*}\|_{2}\|{\bm{r}}\|_{2}\cos\theta$ (S19) $\displaystyle\approx\operatorname*{arg\,min}_{{\mathbf{z}}^{*}}\theta\qquad(\|{\mathbf{z}}^{*}\|_{2}\|{\bm{r}}\|_{2}\approx\text{const}>0).$ (S20) $$

The left plot in Fig. [S9](https://arxiv.org/html/2511.06424v1#A3.F9) measures $\theta$ during image compression with both methods. It confirms our derivation and shows that Turbo-DDCM consistently provides a solution at least as good as DDCM MP. Moreover, while Turbo-DDCM scales with $M$ and continues to improve the approximation as $M$ increases within the presented range, DDCM MP does not benefit from increasing $M$ alone beyond a certain point; it also requires increasing $C$. This hyperparameter interdependency in DDCM MP can lead to suboptimal configurations and limits fine-grained control over the bitrate, since both hyperparameters must be adjusted simultaneously. In addition, it negatively affects runtime efficiency, as discussed in App. [D](https://arxiv.org/html/2511.06424v1#A4).

The middle and right plots in Fig. [S9](https://arxiv.org/html/2511.06424v1#A3.F9) further confirm that the ability to produce a ${\mathbf{z}}^{*}$ with a small angle to the residual translates into improved compression performance, both in terms of distortion and perceptual quality.
The lack of improvement in the DDCM MP angle is reflected in constant distortion and perceptual quality.

Figure: Figure S9: Effect of hyperparameters on Turbo-DDCM Thresholding and DDCM MP: Metrics are shown for compression of the Kodak24 ($512\times 512$) dataset using DDCM and Turbo-DDCM with $T=100$ and $K=1024$, while varying $M$ and $C$. Turbo-DDCM consistently approximates the residual at least as well as DDCM MP and continues to improve the approximation with increased $M$, whereas DDCM MP does not improve the approximation beyond a certain point if $C$ is fixed, which results in constant distortion and perceptual performance. Notably, Turbo-DDCM does not scale with $C$; see App. [E](https://arxiv.org/html/2511.06424v1#A5) for details. The $C$ values used differ from our typical value of 1, since DDCM performs MP with $C\geq 2$.
Refer to caption: x17.png

## Appendix D Thresholding-based Strategy Efficiency

This appendix quantifies the computational efficiency of Turbo-DDCM’s thresholding strategy relative to DDCM’s matching pursuit (MP). As described in Sections [3](https://arxiv.org/html/2511.06424v1#S3) and [4](https://arxiv.org/html/2511.06424v1#S4), both strategies combine multiple atoms from the codebook to obtain improved solutions to the optimization problems. We provide both a theoretical complexity analysis and empirical results. Importantly, both procedures are performed after each diffusion step (except the last one). As a result, in image compression, the total runtime of these algorithms corresponds to the runtime presented in this appendix multiplied by the number of diffusion steps minus one.

### D.1 Theoretical Complexity Comparison

Given a codebook, the MP strategy of DDCM employs a greedy iterative search over $M$ iterations, starting by selecting the atom with the maximum inner product with the residual vector ($x_{0}-\hat{x}_{0|t}$). This step requires an exhaustive search over all $K$ atoms, with a computational cost of $\Theta(Kd)$, where $d$ is the latent space dimensionality. In each of the subsequent $M-1$ iterations, the algorithm searches for an additional atom and a quantized coefficient that, together with the current combination, form a convex combination most correlated with the residual. This search is performed via exhaustive search, and after selecting the atom and coefficient, the combination is normalized to unit standard deviation. The process incurs an additional cost of $\Theta((M-1)2^{C}Kd)$. Therefore, DDCM’s MP complexity is

$$ $\Theta(M2^{C}Kd).$ (S21) $$

In contrast, our approach solves an approximate least squares problem under sparsity and quantization constraints (see App. [C](https://arxiv.org/html/2511.06424v1#A3) for the mathematical foundations). We begin by computing the inner products between all atoms and the residual vector, which requires a computational cost of $\Theta(Kd)$. Next, we efficiently select the top-$M$ most correlated atoms, which can be implemented using a heap-based selection algorithm with a cost of $\Theta(K\log M)$. Finally, quantization is performed using the previously computed inner products by finding the nearest quantized coefficient for each of the $M$ selected atoms, with a complexity of $\Theta(2^{C}M)$. Hence, the overall complexity of our method is

$$ $\Theta(Kd+K\log M+2^{C}M)\;\approx\;\Theta(Kd),$ (S22) $$

since $M\leq K$ and in our typical configurations $M\ll d$ and $C=1$.

Our algorithm eliminates the dependency on $M$ and $C$ presented in DDCM MP, allowing large values of these parameters to be used without significant additional computational cost. As explained in Section [4](https://arxiv.org/html/2511.06424v1#S4), the ability to increase $M$ is critical in our approach for achieving a substantial reduction in the number of diffusion steps, as well as for tuning the bitrate using a single hyperparameter.

### D.2 Empirical Runtime Comparison

To quantify the difference between the algorithms and assess the impact of the constants hidden in the $\Theta$ notation, we measure the runtime of both algorithms while varying one parameter at a time among $K$, $M$, and $C$ (with $d$ fixed). Figure [S10](https://arxiv.org/html/2511.06424v1#A4.F10) confirms our theory and supplies a glimpse for the overall speedup, which passes two orders of magnitude.

Figure: Figure S10: Impact of hyperparameters on the efficiency of DDCM MP vs. Turbo-DDCM thresholding: While DDCM MP scales linearly with $K$ and $M$ and exponentially with $C$, our method scales linearly with $K$ and remains nearly constant in $M$ and $C$, achieving over two orders of magnitude speedup.
Refer to caption: x18.png

Figure [S11](https://arxiv.org/html/2511.06424v1#A4.F11) shows the acceleration achieved across different combinations of $K$ and $M$. In the configurations that characterize Turbo-DDCM, our thresholding approach achieves two to four orders of magnitude runtime speedup over DDCM approach.

Figure: Figure S11: Relative speedup of Turbo-DDCM thresholding over DDCM MP: The heatmap shows the speedup using $C=2$ for both methods, as DDCM MP does not support $C=1$. The orange box shows DDCM’s typical configurations, and the green box shows Turbo-DDCM’s. Our method achieves up to four orders of magnitude speedup in the configurations used by Turbo-DDCM, highlighting the difficulty of using DDCM MP in these regions.
Refer to caption: x19.png

## Appendix E Hyperparameters

Turbo-DDCM has five hyperparameters:

- •
$T$: number of diffusion steps.
- •
$K$: codebook size at each diffusion step.
- •
$M$: number of selected atoms from the codebook at each step ($M\leq K$).
- •
$C$: number of bits per quantization coefficient, yielding $2^{C}$ quantization levels.
- •
$N$: number of DDIM steps performed at the end without requiring bits.

In this appendix, we discuss the trade-offs between these parameters and shed light on our choice for the base configuration: $T=20$, $K=16384$, $C=1$, varying $M$ to control bitrate and $N$ ranging from 0 to 5 depending on the bitrate.

To achieve approximately constant runtime across different bitrates, we fix $T$. We found that $T=20$ provides the best trade-off between performance and runtime. We set $K=16{,}384$ because this value is large enough to span a substantial subspace and, in Stable Diffusion 2.1 Base, the entire latent space. It also allows a wide range of $M$ values. At the same time, this $K$ remains small enough to avoid overcompleteness, ensuring a reasonable approximation of orthogonality (see App. [B](https://arxiv.org/html/2511.06424v1#A2)). With $T$ and $K$ fixed, the bitrate is primarily determined by $M$ and $C$.

The hyperparameters $M$ and $C$ directly affect our ability to obtain a high-quality solution to the optimization problem in eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9)). To understand their marginal impact, we analyze the sources of approximation error in reconstructing the target residual (${\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{t|0}$). The approximation error

$$ $\displaystyle\lVert{\mathbf{z}}^{*}-({\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{t|0})\rVert_{2}^{2},$ (S23) $$

can be decomposed into several components. First, setting constraints aside momentarily, the codebook span may not cover the entire space. Consequently, the best achievable solution is the projection onto the codebook span. If the codebook spans the whole space, this error becomes zero under the assumption that the codebook atoms are linearly independent. Second, we require a sparse solution, so we cannot use the full projection but must find a sparse approximation, which increases the error. Finally, we cannot use this sparse projection directly, but must quantize it, further increasing the approximation error.

Figure: Figure S12: Quantization impact on objective approximation: The figure illustrates the difference in approximating our per-diffusion-step objective defined in eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9)) with and without the quantization constraint. Since we normalize our solutions (eq. ([10](https://arxiv.org/html/2511.06424v1#S4.E10))), the angle between ${\mathbf{z}}^{*}$ and the residual ${\mathbf{r}}$ is proportional to the norm of their difference. The quantized projection is computed with $C=1$, and we observe that it yields nearly the same solution as the sparse projection, which corresponds to the solution obtained without the quantization constraint.
Refer to caption: x20.png

Figure [S12](https://arxiv.org/html/2511.06424v1#A5.F12) illustrates our solutions to the objective with and without the quantization constraint, comparing the sparse projection to the quantized sparse projection with $C=1$. Notably, $C=1$, corresponding to quantization coefficients of $\pm 1$, does not introduce traditional quantization levels. Instead, it allows selection of either the codebook noise vector or its opposite, effectively doubling the codebook size. Using $C=1$, we achieve solutions very close to those of the sparse projection. This behavior can be explained by the fact that the real coefficients are similar in magnitude, making quantization to exact values unnecessary. As a result, we set $C=1$ to our base configuration.

Finally, we use DDIM steps at low bitrates to improve perceptual quality, but at high bitrates where perceptual quality is already good enough, additional DDIM steps may damage distortion. As a result, $N$ decreases with bitrate. See App. [A](https://arxiv.org/html/2511.06424v1#A1) for exact details on $N$.

## Appendix F Bitsteam Protocol

As described in Sec. [4](https://arxiv.org/html/2511.06424v1#S4), we propose an alternative protocol for bitstream transmission, distinct from that used in DDCM. In this appendix, we primarily show that our protocol achieves relative bit savings exceeding 40% and affects our rate-distortion-perception performance. The BPP formulas for both protocols are given in eq. ([8](https://arxiv.org/html/2511.06424v1#S3.E8)) and eq. ([15](https://arxiv.org/html/2511.06424v1#S4.E15)), with the differences arising from how the selected $M$ atom indices are encoded.

The analyses below are performed for a single diffusion step. Since bits are encoded identically for each step in both protocols, the relative differences similarly apply to the total bit count.

##### Relative Bit Saving.

Let $B_{\text{old}}$ and $B_{\text{new}}$ denote the number of bits required per diffusion step for the original DDCM protocol and our proposed protocol,
respectively. Thus,

$$ $B_{\text{old}}=M\lceil\log_{2}K\rceil+MC\quad\text{and}\quad B_{\text{new}}=\left\lceil\log_{2}\binom{K}{M}\right\rceil+MC.$ (S24) $$

The relative saving ratio is therefore

$$ $\Delta=\frac{B_{\text{old}}-B_{\text{new}}}{B_{\text{old}}}.$ (S25) $$

Using the Stirling approximation

$$ $\log_{2}\binom{K}{M}\approx M\log_{2}\frac{K}{M}+\mathcal{O}(M).$ (S26) $$

Assuming C is small (see App. [E](https://arxiv.org/html/2511.06424v1#A5)), we can express the saving ratio as

$$ $\Delta\approx\frac{M\log_{2}K-M\log_{2}\tfrac{K}{M}}{M\log_{2}K}=\frac{M\log_{2}M}{M\log_{2}K}=\frac{\log_{2}M}{\log_{2}K}.$ (S27) $$

Thus, the relative savings depend logarithmically on the ratio of $M$ to $K$, becoming more significant as $M$ increases relative to $K$. For example, with $K=16{,}384$ and $M=100$, which yields a BPP of 0.0667 in the new protocol for $T=20$, $N=1$, $C=1$, and an image resolution of $512\times 512$, the relative reduction is approximately

$$ $\frac{\log_{2}100}{\log_{2}16384}\approx 47\%.$ (S28) $$

##### Empirical Evaluation

We evaluate the relative bit savings by focusing on the transmission of the selected indices, which constitutes the dominant portion of the rate when $C$ is small. As shown in Fig. [S13](https://arxiv.org/html/2511.06424v1#A6.F13), the empirical results align with the theoretical analysis, demonstrating a substantial reduction in rate (>40%).
Moreover, Fig. [S14](https://arxiv.org/html/2511.06424v1#A6.F14) shows that without the new bit protocol, Turbo-DDCM underperforms in rate–distortion–perception metrics compared to DDCM, whereas with the protocol it achieves equivalent performance.

Figure: Figure S13: Relative bit saving: Percentage of bits saved when transmitting the selected atom indices using our protocol compared to the original DDCM protocol. To illustrate a continuous trend, the plot omits the ceiling operator in the bitrate expressions, which does not affect the asymptotic behavior. For the Turbo-DDCM configuration with $K=16{,}384$, bitrate savings can exceed 40%.
Refer to caption: x21.png

Figure: Figure S14: Impact of bitstream protocol on rate-distortion-perception: The plot evaluates DDCM, Turbo-DDCM with DDCM protocol, and Turbo-DDCM, which employs our new protocol, on the Kodak24 dataset. While Turbo-DDCM with the original protocol underperforms relative to DDCM, the new protocol allows it to achieve equivalent performance.
Refer to caption: x22.png

##### Implementation Details.

To efficiently determine the lexicographic index of the chosen combinations, we precalculate the relevant binomial coefficients and sum the required values at runtime.

## Appendix G Turbo-DDCM Distortion-Controlled Variant

Current diffusion-based image compression algorithms generally take an image and a target bitrate, specified via hyperparameters, as input. However, for a fixed bitrate, the resulting distortion can vary significantly across images. The left plot in Fig. [S15](https://arxiv.org/html/2511.06424v1#A7.F15) illustrates this for zero-shot diffusion-based methods, showing that PSNR values at a given bitrate can deviate from the mean by more than 2 dB. To improve the predictability of the outputs, it may therefore be preferable to target distortion rather than bitrate.

Figure: Figure S15: Distortion variance between images at a fixed bitrate: All zero-shot methods exhibit high distortion variability across images when evaluated at the same bitrate. In addition, the same images tend to have similar deviations from the mean under both PSC and Turbo-DDCM, despite the fundamental differences between the two methods. Both plots use the DIV2K ($512\times$512) dataset.
Refer to caption: x23.png

In this appendix, we propose an efficient method based on Turbo-DDCM, which can also be adapted to other methods, that takes an image and a target distortion as input and predicts the appropriate bitrate to achieve it. We observe that, for a given image, its PSNR deviation from the dataset mean at a fixed bitrate is highly correlated across different methods. For example, the right plot in Fig. [S15](https://arxiv.org/html/2511.06424v1#A7.F15) demonstrates a strong correlation between PSC and Turbo-DDCM, despite their fundamentally different designs. This observation motivates us to investigate correlations with simple, non-neural methods such as JPEG, which offer ultra-fast compression.

Figure: Figure S16: Correlation between JPEG file size and distortion in zero-shot compression: Linear regressions are shown between JPEG file size (at different quality levels) and PSNR obtained by each method, for BPPs in the range $0.045$-$0.065$. All methods exhibit a strong inverse correlation. Experiments are conducted on the DIV2K dataset, center-cropped to $512\times 512$ images.
Refer to caption: x24.png

In Fig. [S16](https://arxiv.org/html/2511.06424v1#A7.F16), we compress images using JPEG at various quality levels and compared the resulting file sizes to PSNR values obtained with zero-shot diffusion-based methods at a specific bitrate. A strong correlation is observed in all quality levels, which may reflect common compression challenges across all methods, such as the difficulty of compressing images with many objects.

Leveraging this observation, we propose a method for PSNR control with Turbo-DDCM. First, given a training set, compress all images using high-quality JPEG. Next, compress the same images with Turbo-DDCM at various bitrates and learn the correlation between JPEG file size and Turbo-DDCM PSNR for each bitrate via linear regression. To compress a new image to a target PSNR, we first compress it with JPEG and, based on its JPEG file size, predict its Turbo-DDCM PSNR at each bitrate using the learned linear regressions. Finally, we select the bitrate whose predicted PSNR is closest to, but not below, the target. If no such bitrate exists, we choose the highest available bitrate.

To evaluate our approach, we use a large dataset - CLIC2020 (CLIC2020), with images center-cropped to $512\times 512$. We first filter out highly difficult images whose JPEG file size at quality 100 exceeds 300 KB, which constitute less than 4% of the dataset. These images are excluded because achieving high PSNR values on them is difficult, almost regardless of the used bitrate. The remaining dataset is split into training and test sets, with 80% of the images used for training and 20% for testing. Both sets are then compressed with JPEG at quality 100. We train a linear regression model for each bitrate on the training set. Finally, for each image in the test set and target PSNR, we determine the bitrate via the above method and evaluate the actual PSNR. The naive approach we compare against selects, for each image, the bitrate whose mean PSNR is closest to the target PSNR. As shown in Fig. [S17](https://arxiv.org/html/2511.06424v1#A7.F17), our method achieves over a 40% RMSE reduction on the test set across most target PSNR target values compared to the naive approach.

Figure: Figure S17: Distortion control evaluation: Our method brings the actual distortion much closer to the target, reducing RMSE by over 40% for most target PSNRs. Results in both plots are reported on the test set.
Refer to caption: x25.png

## Appendix H DDCM and Turbo-DDCM vs. DiffC

DDCM, Turbo-DDCM, and DiffC are all state-of-the-art zero-shot compression methods, achieving comparable compression quality (Fig. [4](https://arxiv.org/html/2511.06424v1#S5.F4)).
While DiffC is based on the reverse-channel-coding (RCC) principle introduced by theis2022algorithmscommunicationsamples, Turbo-DDCM builds on DDCM (ohayon2025compressed), which is not motivated from a solid theoretical foundation. Interestingly, both DDCM-based methods and DiffC optimize the same core objective, yet extend it in fundamentally different ways. In this appendix, we first illustrate DiffC and its underlying motivation, and then highlight its similarities and differences from DDCM and Turbo-DDCM.

### H.1 Shared Core Optimization Objective

All three methods are based on solving optimization problems. The optimization problem of DDCM is presented in Section [3](https://arxiv.org/html/2511.06424v1#S3), that of Turbo-DDCM in Section [4](https://arxiv.org/html/2511.06424v1#S4), and we now turn to the optimization process of DiffC which is based on RCC. In each diffusion step, DiffC aims to communicate the forward diffusion distribution $q({\mathbf{x}}_{t-1}\mid{\mathbf{x}}_{0},{\mathbf{x}}_{t})$ to the decoder, assuming both can sample from the reverse distribution $p_{\theta}({\mathbf{x}}_{t-1}\mid{\mathbf{x}}_{t})$. This communication is performed only for a specific number of initial diffusion steps, which depends on the target bitrate, similar to Turbo-DDCM. The broadcasted information is then used to steer the diffusion process toward the target image via a strategically chosen diffusion noise vector, similar to the approach in Turbo-DDCM.

vonderfecht2025lossy implement DiffC by applying RCC using the Poisson-Functional-Representation (PFR) approach presented by theis2022algorithmscommunicationsamples. In their implementation, the PFR algorithm iteratively samples i.i.d. Gaussian noise vectors, selecting the noise ${\mathbf{z}}_{i}$ that minimizes $p_{\theta}({\bm{z}}_{i})/q({\bm{z}}_{i})$. Exploiting the isotropy of both distributions, they simplify this deviation to

$$ $\displaystyle h_{i}:=\exp\left(-\frac{({\bm{\mu}}_{q}-{\bm{\mu}}_{p_{\theta}})^{T}{\bm{z}}_{i}}{\sigma_{p_{\theta}}}\right),$ (S29) $$

where ${\bm{\mu}}_{q}$ and ${\bm{\mu}}_{p_{\theta}}$ are the means of $q$ and $p_{\theta}$, respectively, and $\sigma_{p_{\theta}}$ is the standard deviation of $p_{\theta}$.
The iterations for searching the best noise are prioritized, favoring early iterations through an increasing multiplicative weight
$w_{i}=\sum_{j=1}^{i}{\bm{e}}_{j}$ for the $i$-th iteration, where ${\bm{e}}_{j}\sim\exp(1)$ are i.i.d. exponential random variables.
The noise with the minimum weighted score, computed as the product of $w_{i}$ and $h_{i}$, replaces the randomly sampled noise in the DDPM reverse process (eq. ([2](https://arxiv.org/html/2511.06424v1#S3.E2))).

Temporarily ignoring prioritization, DiffC optimization can be formulated as

$$ $\displaystyle\operatorname*{arg\,min}_{{\bm{z}}_{i}}\exp\left(-\frac{({\bm{\mu}}_{q}-{\bm{\mu}}_{p_{\theta}})^{T}{\bm{z}}_{i}}{\sigma_{p_{\theta}}}\right)=\operatorname*{arg\,max}_{{\bm{z}}_{i}}({\bm{\mu}}_{q}-{\bm{\mu}}_{p_{\theta}})^{T}{\bm{z}}_{i}.$ (S30) $$

Placing the values of the means, it simplifies to

$$ $\displaystyle\operatorname*{arg\,max}_{{\bm{z}}_{i}}(((c_{1}{\mathbf{x}}_{0}+c_{2}{\mathbf{x}}_{t})-(c_{1}\hat{{\mathbf{x}}}_{0|t}+c_{2}{\mathbf{x}}_{t}))^{T}{\bm{z}}_{i})=\operatorname*{arg\,max}_{{\bm{z}}_{i}}\langle{\bm{z}}_{i},{\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}\rangle,$ (S31) $$

where $c_{1}$ and $c_{2}$ are time-dependent constants. This objective is actually the original DDCM objective for the case of $M=1$, meaning no matching pursuit is performed (eq. ([6](https://arxiv.org/html/2511.06424v1#S3.E6))). Since $\lVert{\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t}\rVert_{2}$ is constant regardless of ${\bm{z}}_{i}$, and $\lVert{\bm{z}}_{i}\rVert_{2}$ is approximately constant in high dimensions, eq. ([S31](https://arxiv.org/html/2511.06424v1#A8.E31)) can be written as

$$ $\displaystyle\operatorname*{arg\,min}_{{\bm{z}}_{i}}\lVert{\bm{z}}_{t}-({\mathbf{x}}_{0}-\hat{{\mathbf{x}}}_{0|t})\rVert_{2}^{2},$ (S32) $$

which is equivalent to Turbo-DDCM’s objective for the case of $M=1$ (eq. ([9](https://arxiv.org/html/2511.06424v1#S4.E9))).
Thus, all three methods steer the diffusion process towards the target image based on the same core objective.

### H.2 Differences Between Methods

Although these methods share the same core objective, they differ in several key aspects.

##### Sampled Noise Prioritization.

As mentioned above, DiffC weights the sampled noises by their sampling iteration number, whereas DDCM and Turbo-DDCM treat all noises equally, without prioritization. While noise prioritization can improve compression on average using variable-length encoding such as Zipf coding used by DiffC, DDCM and Turbo-DDCM provide a constant and predictable bitrate across images. Figure [S18](https://arxiv.org/html/2511.06424v1#A8.F18) illustrates that DiffC’s bitrate varies significantly between images, with deviations exceeding 25% from the mean, even when using the same target bitrate hyperparameters.

##### Increase of the Effective Search Space

Turbo-DDCM and DiffC employ different strategies to effectively explore a large space of sampled noise vectors. DiffC achieves this by partitioning both ${\mathbf{z}}_{i}$ and ${\bm{\mu}}_{q}-{\bm{\mu}}_{p_{\theta}}$ into chunks and independently solving each optimization problem via exhaustive search. If the search is performed over $x$ iterations per chunk across $c$ independent chunks, this effectively explores $x^{c}$ possible noise maps with only $x\times c$ exhaustive search iterations. In contrast, Turbo-DDCM performs effective multiple-atom selection.
This explores $\binom{K}{M}\times 2^{M\times C}$ combinations, where $K$ is the codebook size, $M$ is the number of chosen atoms, and $2^{C}$ denotes the number of possible non-zero quantization coefficients.

##### Search Space Size along Diffusion Steps.

Supported by theoretical justifications, DiffC progressively increases both the number of chunks and the number of search iterations as the reverse diffusion process advances. In contrast, DDCM and Turbo-DDCM maintain a fixed codebook size and a fixed number of selected atoms across all diffusion steps. Importantly, while DiffC requires a custom CUDA kernel due to performing $2^{16}=65{,}536$ evaluations per chunk across more than 400 chunks in later diffusion steps, Turbo-DDCM achieves multiple atom selection through an efficient closed-form solution without requiring custom hardware-specific acceleration. The progressively increasing search complexity in DiffC is a major factor behind its growing runtime with bitrate, as shown in Figure [4](https://arxiv.org/html/2511.06424v1#S5.F4). As the bitrate increases, the encoder performs more intensive optimization across a greater number of diffusion steps.

### H.3 Turbo-DDCM Vs. Accelerated DiffC

vonderfecht2025lossy mention the option to reduce DiffC runtime by decreasing the number of inference steps. To evaluate both methods under comparable runtimes, we create a faster variant of DiffC using this approach. Since DiffC’s runtime varies significantly across bitrates, we reduce the number of diffusion steps to approximately match Turbo-DDCM’s runtime at DiffC’s minimum runtime. This results in just a few encoding steps for DiffC at low bitrates, increasing up to 10 steps at high bitrates. We refer to this new configuration as *Fast-DiffC*.

Figure: Figure S18: Actual BPP variance in DiffC across images: DiffC exhibits variable BPP, which can deviate from the mean by more than 25% under the same BPP target. $t_{\text{final}}$ is the final timestep up to which the encoder performs RCC and communicates the result to the decoder. This hyperparameter controls the target BPP.
Refer to caption: x26.png

Figure [S19](https://arxiv.org/html/2511.06424v1#A8.F19) shows that Fast-DiffC maintains comparable distortion to the original DiffC across all bitrates, but its perceptual quality is notably inferior to both DiffC and Turbo-DDCM except at the highest bitrate. One possible explanation for this phenomenon is that RCC is computationally demanding due to the large number of evaluations required, even with custom CUDA kernel. Thus, Fast-DiffC is forced to perform fewer diffusion steps than Turbo-DDCM, whose inter-step mechanism is more efficient, in order to achieve comparable runtime.

Figure: Figure S19: Fast-DiffC evaluation: Fast-DiffC maintains the equivalent distortion to DiffC. However, it has much worse perception. The evaluation uses the Kodak24 ($512\times 512$) dataset.
Refer to caption: x27.png

## Appendix I LLM Usage

Large language models (LLMs) were used for minor text polishing and readability improvements.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 4
presentation: 3
questions: 1. The article's overview of the overall encoding and decoding process is somewhat vague. It would be beneficial to include a pseudocode  to provide readers with a clearer understanding of the algorithm's encoding and decoding processes.
2. The use of ROI in the article for flexible bitrate allocation is commendable. However, the paper lacks details on the application of this technology. For instance, is ROI specific to this algorithm only? Can it be integrated with DDCM or other zero-shot schemes? What is the specific process of implementing ROI? Does ROI introduce additional inference latency? These aspects should be further elaborated.
3. The article showcases the Round Trip Time. What does this specifically refer to? In a compression algorithm, it's essential to separately compare encoding and decoding times.
4. The article employs a 512 central crop for the Kodak dataset, which is relatively uncommon in the compression field where full-size Kodak testing is more prevalent. Is there a specific reason for this approach? Is it related to high GPU memory usage by the algorithm?
5. Testing FID on the Kodak dataset may not be appropriate as Kodak comprises only 24 images, and even when divided into 64-pixel patches, reliable FID metrics may not be guaranteed.
6. CLIC20 is a commonly used dataset in image compression. It would enhance the algorithm's reliability to include CLIC20 in the main experiments.
soundness: 2
strengths: 1. The paper is well-written, with clear expression and concise yet precise explanations of the motivation and methodology.
2. The theoretical explanations are solid, providing a high level of theoretical underpinning for the approach.
3. The experiments are comprehensive, comparing all zero-shot diffusion-based image compression baselines and achieving satisfactory performance even with a several-fold acceleration
summary: The paper introduces a zero-shot algorithm based on a pre-trained diffusion model to achieve image compression at extremely low bit rates. In essence, this method represents an efficient enhancement of the DDCM approach, transforming the original MP method into MULTI-ATOM and proposing a new bit protocol to further reduce the redundancy in the bitstream generated by the MULTI-ATOM method. The paper presents a plethora of experiments and evidence to validate the effectiveness and reliability of the algorithm. The experiments demonstrate that this approach achieves excellent performance metrics in zero-shot diffusion-based schemes.
weaknesses: 1. Some modules lack sufficient explanations, especially those borrowed from other articles. Providing necessary explanations can help readers better understand the operational mechanisms of the entire algorithm.
2. The lack of striking innovativeness in the algorithm may be noted, as the entire solution builds upon the pipeline of DDCM and does not surpass DiffC in terms of performance.
3. I believe confining the baselines to the zero-shot domain is inappropriate. While zero-shot algorithms show promise and are worth researching in diffusion-based image compression schemes, all zero-shot algorithms fundamentally sacrifice rapid inference to reduce or eliminate training costs, whereas compression tasks are sensitive to inference latency. Recently, some solutions based on few-step pre-trained diffusion models [1,2] have achieved outstanding performance with minimal latency. Overall, I suggest that the method should be compared against some non-zero-shot diffusion baselines or explore the potential application of this algorithm in fine-tuning diffusion priors, which could enhance the practical contributions and persuasiveness of the paper.

[1] [TCSVT] RDEIC: Accelerating Diffusion-Based Extreme Image Compression with Relay Residual Diffusion

[2] [ICCV 2025] StableCodec: Taming One-Step Diffusion for Extreme Image Compression

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: 1.	What is the meaning of the symbol C in Eq. (8)?
2.	The author should provide a detailed explanation of the encoding and decoding process in Figure 2.
3.	What is the meaning of log2(K M) in Eq. (14)?
4.	It is difficult to distinguish the differences among the decoded images in the first row of Figure 1.
5.	In Figure 4, when comparing with other methods, the authors should also provide the results on the DIV2K dataset.
6.	The proposed method should be compared with GAN-based algorithms.
7.	When comparing computational complexity, the authors should also provide GPU memory usage.
8.	The author should analyze the impact of the values of hyperparameters T, K, and C on performance.
soundness: 3
strengths: Turbo-DDCM has a competitive performance with recent methods in terms of the rate-distortion-perception tradeoff, and it achieves up to an order of magnitude speedup over existing methods.
summary: This paper proposes a fast and flexible zero-shot diffusion-based image compression method (i.e., Turbo-DDCM), which reduces the number of required denoising operations and maintains the performance with an improved encoding protocol. Moreover, Turbo-DDCM presents a priority-aware variant that prioritizes regions of interest and a distortion-controlled variant that compresses an image based on a target PSNR. Experiments are performed on Kodak and DIV2K datasets to investigate the effectiveness of the proposed method.
weaknesses: 1.	The experimental section lacks comprehensive quantitative results, such as BD-rate or BD-PSNR.
2.	The workflow description of the proposed method is not concise enough.
3.	Although the proposed method is faster than the comparison algorithm, it does not offer a performance advantage.
4.	The paper does not analyze the advantages of diffusion-based image compression methods compared to other types of image compression models, such as GAN, CNN, and RNN.
5.	No results tables are provided for better indicating its superiorities over other methods.

---

confidence: 5
contribution: 4
initial_rating: 8
presentation: 4
questions: The other available zero-shot diffusion compression methods (DDCM, and DiffC) have hyperparameters for speeding up their runtime by trading off against their rate/distortion performance. Primarily this means the number of denoising steps performed. It would be very interesting to see how these methods fare as you decrease the number of denoising steps to match Turbo-DDCM.

It's not obvious to me that the z_t* vectors selected by turbo-DDCM should yield x_{t-1} vectors which are in the same distribution that the diffusion model was trained on? Like the diffusion model was trained to expect specific linear combinations of real images + gaussian noise, at different ratios, for each time step. But when you generate z_t* according to this fancy process, does it still have the same statistics that random noise does, from the perspective of the diffusion model? Like you are selecting these vectors to be correlated with the target image, so I would naively expect them to have different statistics from random noise. But I'm not confident in this assessment.
soundness: 4
strengths: This is a clever idea for improving the computational efficiency of noise-vector selection in zero-shot DDPM-based compression. It clearly works quite well.
summary: Turbo-DDCM proposes a new approach to zero-shot diffusion-based compression. In the original Denoising Diffusion Codebook Models (DDCM) approach, at each denoising timestep, the compression algorithm selects the next noise vector to add to the image from a codebook of K noise vectors, y selecting the one which moves the noisy image closest to the target image. In Turbo-DDCM, the authors instead encode a noise vector by selecting a subset of M of those K random vectors, and taking a linear combination of them, with coefficients either -1 or 1. This effectively allows the authors to select from a combinatorially larger set of noise vectors, getting closer to the target image with each step. With this improved guidance, they can steer the diffusion model to produce the target image in many fewer steps. They empirically show that this method allows for zero-shot image compression using diffusion models which is multiple times faster than prior approaches.
weaknesses: I consider all of these zero-shot methods (DiffC, DDCM, Turbo-DDCM) to be modifications of Theis et al's original DiffC proposal. They all, to various degrees, trade off theoretical elegance/rigor for real-world usability. In the original 2022 algorithm, there's a precisely defined relationship between the diffusion model's log probability of an image and the number of bits needed to compress that image to a certain noise level. Turbo-DDCM achieves state-of-the-art real-world performance, but trades away these theoretical guarantees.

---

confidence: 5
contribution: 2
initial_rating: 2
presentation: 1
questions: 1. What are the backbones of all zero-shot diffusion-based methods? For a fair comparison of speed, the proposed method should have the same backbone as these methods.
2. Does the author use Turbo-Lora to accelerate Stable Diffusion 2.1?
3. What is the speed of non-diffusion-based methods? The author should also compare with them.
4. How to process higher resolutions?

Please reply to the Weaknesses and Questions. Based on the author's response, I will adjust my rating.
soundness: 3
strengths: 1. The paper is easy to read.
2. The paper proposes a method which has a faster speed than existing zero-shot diffusion-based image compression methods.
summary: The paper proposes an efficient zero-shot diffusion-based image compression method, which is based on the Denoising Diffusion Codebook Models (DDCMs) compression scheme. The paper modifies DDCM with Turbo-DDCM and introduces two flexible variants of Turbo-DDCM.
weaknesses: 1. The novelty and contribution are weak. The author just modified the DDCM, but there is no ablation study to analyze the proposed components.
2. The presentation is incomplete. There is a lack of quantitative comparison and ablation study. And there are no tables in the whole paper.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: See weaknesses.
soundness: 4
strengths: 1. The motivation is reasonably elaborated and well-supported in the subsequent methods and experiments. The time issue is a key concern in the field of image diffusion research based on diffusion architectures, and the authors have properly proposed a new noise reconstruction method to tackle this.
2. The structure of the paper is clear and well-written.
summary: This paper addresses the issues of slow speed and high computational resource requirements of DiffC by proposing the Turbo-DDCM method. As a continuation of DiffC methods based on the RCC theory, TurboDDCM well inherits advantages such as zero-shot capability and achieves improvements in speed and performance.
weaknesses: 1. The authors only conducted time comparisons within the RCC field. It would be valuable to know the speed comparison with diffusion compression methods based on condition introduction and fine-tuning. Specifically, whether RCC-based image compression has time advantages over fine-tuning-diffusion-based image compression, especially given the emergence of many one-step diffusion image compression methods (e.g., StableCodec).
2. Following the first point, for fewer time steps (e.g., 5 steps or even a single step), does the performance of the proposed method degrade significantly?
3. The performance improvement of the final results seems not particularly significant, and the comparisons are insufficient. The baselines selected by the authors appear to be consistent with those of DiffC, but DiffC is a work from ICLR25. It is suggested that the authors include more comparisons with recent works from the past year, such as DiffEIC and StableCodec.
---
ref: 

[1] Li Z, Zhou Y, Wei H, et al. Towards extreme image compression with latent feature guidance and diffusion prior[J]. IEEE Transactions on Circuits and Systems for Video Technology, 2024.

[2] Zhang T, Luo X, Li L, et al. StableCodec: Taming One-Step Diffusion for Extreme Image Compression[J]. arXiv preprint arXiv:2506.21977, 2025. (ICCV25 accepted)


Decision: Accept (Poster)