{"id":"78cdd73f-0d26-4cbf-bce3-46dccaa5a2b6","arxiv_id":"2501.09815","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"A complete, zero-shot implementation of the DiffC algorithm lets pretrained Stable Diffusion models act as lossy image compressors at ultra-low bitrates.","lead":"The authors implemented the previously theoretical DiffC compression algorithm on top of four pretrained Stable Diffusion and Flux models, adding a fast GPU reverse-channel coder and an optimized denoising schedule. The system compresses images at ultra-low bitrates without training, and the paper reports rate-distortion results competitive with purpose-built generative compressors.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The zero-shot claim is not yet supported because the timestep and per-step DKL schedules used to produce the rate-distortion curves are optimized on the same Kodak/Div2K images used for evaluation; a held-out schedule test is required.","rationale":"The reader's weakest-assumption analysis identifies the same load-bearing concern I see: the timestep schedule and hard-coded DKL schedule are computed from the very images used to report rate-distortion performance. This matters because the paper's central claim is explicitly zero-shot competitive performance. If those schedules are tuned to the evaluation set, the reported bitrates are optimistic for a user who applies the method to new images. The paper's own robustness evidence in Appendix A.5 is suggestive but not dispositive: the perturbations tested are all centered on the dataset-specific mean, so they do not establish independence from the calibration set. This is a fixable evaluation issue rather than a fundamental algorithmic flaw. The PFR implementation, the CUDA kernel, and the code release are real contributions, and I see no evidence of circular reasoning or internal inconsistency in the algorithm itself. A held-out schedule test with error bars would settle the matter. Therefore the appropriate verdict remains CONDITIONAL, and since the reader already assigned CONDITIONAL, I recommend no change to the verdict.","tokens_in":14271,"tokens_out":10044,"duration_ms":114287,"concrete_test":"Use SD1.5 on Kodak. Compute the timestep and per-step DKL schedules from a disjoint calibration set, e.g., 30 DIV2K images, or better, leave-one-out on Kodak: compute the schedule from 23 Kodak images and evaluate on the held-out image, averaging over all 24 folds. Regenerate the Kodak rate-distortion points with this held-out schedule using the same PFR implementation, and repeat each point with 5 independent RCC seeds to obtain means and standard deviations. If the held-out curve stays within 0.5 dB PSNR (or within 10% bitrate) of Figure 2 at each ultra-low bitrate, the zero-shot claim is supported; if the gap is larger, the reported curves overstate performance for unseen images.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that DiffC works zero-shot on pretrained diffusion models and is competitive at ultra-low bitrates. For that claim to hold, the reported bitrates must be achievable without prior access to the test images. The paper's protocol does not satisfy this: Algorithm 3 takes as input the exact set of images to be encoded ('X: dataset of images to encode (e.g. Kodak 24)') and returns a minimum-cost timestep schedule by averaging DKL over that set. Section 3.5 and Appendix A.5 then hard-code the per-step DKL values as the mean (or multiples of the mean) computed over the same images. Thus both the coding schedule and the DKL sequence are fitted to the evaluation set, so the rate-distortion curves in Figure 2 are conditional on the test data rather than a demonstration of zero-shot behavior. This is not an internal inconsistency, but it directly weakens the headline claim. The robustness experiment in Figure 5 only varies the DKL schedule around the dataset mean (quarter, half, mean, min, max, double, quadruple), so it does not rule out a schedule-dependent bias; a schedule derived from an unrelated dataset could shift the curves. In addition, PFR is stochastic, and the curves are shown without error bars, so the size of any schedule-induced shift is currently unknown.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents DiffC, a full implementation of the diffusion-based lossy compression algorithm of Theis et al. (2022), applied zero-shot to pretrained Stable Diffusion 1.5, 2.1, XL, and Flux-dev. The authors contribute a fast CUDA implementation of Poisson functional representation (PFR) for reverse-channel coding, a greedy shortest-path algorithm for choosing denoising timestep schedules, and a hard-coded per-step DKL schedule intended to avoid side information. They report rate-distortion curves on Kodak and DIV2K against HiFiC, MS-ILLM, PerCo, and DiffEIC, and claim competitiveness at ultra-low bitrates, with SD1.5 encoding times under 10 seconds. The paper also adapts DiffC to flow-matching models by an SNR-preserving rescaling between OT-flow and DDPM timesteps.","tokens_in":14582,"tokens_out":5418,"duration_ms":56895,"significance":"If the claims hold, this is a valuable systems contribution: it is the first complete DiffC implementation, the public release includes a working CUDA RCC kernel, and the engineering removes a known bottleneck that had prevented full implementations. The conceptual framework is sound, and the paper honestly reports practical overheads and the fidelity limits imposed by the latent VAE. However, the central 'zero-shot' claim is currently too strong because both the timestep schedule and the per-step DKL values are derived from the very images used for evaluation. With a held-out schedule validation and a more precise baseline comparison, the method could become a strong training-free baseline for generative compression.","major_comments":[{"comment":"Algorithm 3 takes as input X, the dataset of images to be encoded, and computes the timestep schedule by averaging per-step DKL over exactly those images; Appendix A.5 then hard-codes the per-step DKL schedule as the mean (or multiples of the mean) over the same Kodak/Div2K images. Consequently, the rate-distortion curves in Figure 2 are produced with schedules that have been fitted to the evaluation set, which does not demonstrate zero-shot performance for unseen images. The robustness experiment in Figure 5 varies the DKL schedule only around the dataset-mean value and therefore does not exclude a schedule-dependent bias that would appear with a schedule derived from an unrelated dataset. Please provide R-D curves using schedules fixed in advance from a held-out set (for example, computed on a different dataset or on a subset disjoint from the evaluation images) and report the resulting shift in PSNR, LPIPS, CLIP, and Q-Align at matched bitrates.","section":"§3.2, §3.5, Appendix A.5"},{"comment":"The comparisons against HiFiC, MS-ILLM, PerCo, and DiffEIC do not state whether those baseline curves were recomputed with the same code and preprocessing, or taken from prior papers. If they are taken from prior publications, differences in evaluation protocol (Div2K subset selection, resizing or cropping, and the treatment of VAE reconstruction bounds) can bias the comparison. Please specify the origin of each baseline curve and, where feasible, evaluate the baselines on the identical preprocessed images used for DiffC.","section":"§4.2, Figure 2"},{"comment":"The abstract claims the method is 'capable of compressing and decompressing images using Stable Diffusion in under 10 seconds,' but Table 1 reports SD1.5 encoding times up to 9.4 s and decoding times up to 8.5 s, so the combined encode-plus-decode time can exceed 18 s. If the claim refers to encoding alone, the wording should be corrected; if it refers to the full round trip, the claim is contradicted by the table. This should be clarified and the abstract adjusted accordingly.","section":"Abstract and Table 1"},{"comment":"The R-D curves are shown without error bars or confidence intervals, but the encoding and decoding procedure is stochastic: PFR draws random samples, and the final reconstruction therefore varies across runs unless the random seeds are fixed. The paper does not state how many random trials were averaged, nor whether the plotted points are single runs. Without this information, the small differences between methods at matched bitrates are difficult to interpret. Please report the variance over PFR randomness, for example by encoding each image several times and showing standard errors.","section":"§4.2, Figures 2 and 4"}],"minor_comments":[{"comment":"The notation 'Dkl' appears with inconsistent capitalization; please use a single consistent notation such as D_KL throughout, including in Section A.5.","section":"§2.4"},{"comment":"There are typographical errors: 'neglegible' should be 'negligible', and 'paralellism' should be 'parallelism'.","section":"§3 and §3.1"},{"comment":"Line 3 of Algorithm 3, 'Sample xT ∼ q(xT|x0) using p(xT)', is unclear: it should explain whether this is a direct sample from q that the receiver can reconstruct, or an RCC step, and how the receiver obtains the sample without side information.","section":"§3.2, Algorithm 3"},{"comment":"The summation notation 'tX i=T' in the displayed formula is awkward and hard to read; please rewrite it as a standard sum over the relevant timestep indices.","section":"§2.3, Equation (1)"},{"comment":"The dataset names are written inconsistently as 'Kodak', 'Div2K', and 'Div2k-1024'; please standardize the capitalization and the precise subset used for each curve.","section":"§4.2 and Table 1"},{"comment":"The cost figures for training Stable Diffusion are cited to Wikipedia, which is not an appropriate source for a research paper; please replace this citation with a primary source or remove the claim.","section":"§1"},{"comment":"The legend labels such as 'quarter mean' and 'twice mean' are ambiguous; please write 'one quarter of the mean' and 'twice the mean' for clarity.","section":"Figure 5 caption"}],"recommendation":"major_revision","confidential_remarks":"The paper is within scope for a computer vision or machine learning venue. The main risk is the test-set-derived schedule: if the authors cannot produce a held-out schedule evaluation, the zero-shot claim must be substantially weakened. The engineering contribution is solid and the public code is a plus, but the current evaluation protocol does not yet support the headline claim. I do not see citation or novelty concerns beyond the schedule issue."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The genuine contribution here is that DiffC finally runs end-to-end. Theis et al. left reverse-channel coding as an open bottleneck; this paper ships a CUDA PFR implementation, a greedy timestep schedule, a DDPM/OT-flow transformation for Flux, and code. That is real engineering value, and the RD curves against HiFiC, MS-ILLM, PerCo, and DiffEIC are plausible at ultra-low bitrates. The paper also honestly reports the gap to the hypothetical ideal-RCC bound and includes an appendix exploring DKL-schedule robustness. I would not want to lose this work.\n\nThe soft spot is the one flagged in the stress test, and it is real. Algorithm 3 takes the evaluation dataset (Kodak or Div2K) as input and returns the timestep schedule that minimizes average bitrate on those images. Appendix A.5 then hard-codes per-step DKL values as means (or multiples of the mean) computed over the same images. The RD curves in Figure 2 are therefore conditional on the test set. That does not make the implementation circular or fake, but it does undercut the \"zero-shot\" claim: a user on unseen images would not have those schedules unless they first ran the optimization on the images they were about to compress. The robustness experiment in Figure 5 only scales the dataset-mean DKL by constants, so it does not tell you what happens with a schedule derived from a fully separate dataset. This is a measurement problem, not an algorithmic one, and it looks fixable: derive schedules on one dataset, evaluate on another, or at least show that the schedule from one dataset transfers without meaningful RD shift.\n\nMinor points: the PFR coder is stochastic, and the curves come without error bars, so we do not know how much noise is in the comparisons. Also, the \"competitive\" claim leans on which metric you prioritize; the paper is honest about the VAEs limiting fidelity, but the headline is a bit broader than the supporting numbers.\n\nWho is this for? People working on generative compression and anyone building on DiffC. The code release and the first complete implementation justify a serious referee; the schedule-leak issue should be addressed before publication. I would engage with this work and would cite it, but I would want the held-out schedule experiment before trusting the zero-shot numbers.","headline":"First working DiffC implementation on pretrained diffusion models, with a real evaluation weakness: the schedules are tuned on the very test images used for the rate-distortion curves.","tokens_in":15098,"tokens_out":1026,"would_cite":true,"duration_ms":14401,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Pretrained latent diffusion models can serve as complete zero-shot lossy image compressors: the first full implementation of the DiffC algorithm encodes images with Stable Diffusion in under 10 seconds and reaches rate-distortion curves…","keywords":["lossy image compression","diffusion models","reverse-channel coding","Poisson functional representation","rate-distortion","zero-shot","latent diffusion","generative compression"],"falsifier":"Encode a held-out set of images that were not used to compute Algorithm 3's step schedule or the mean per-step DKL values, using the released protocol; if the rate-distortion curve drops noticeably relative to the reported Kodak/Div2K curves, the zero-shot claim overstates what users will see on new images.","tokens_in":14049,"feed_emoji":"🗜️","tokens_out":7839,"duration_ms":75426,"temperature":0.7,"pith_summary":"This paper claims that the DiffC algorithm—lossy compression by communicating a noised latent through a shared diffusion model's reverse process—can be fully implemented on top of pretrained latent diffusion models without any additional training. The authors introduce practical workarounds for reverse-channel coding, the step that had prevented DiffC from being completed, and demonstrate the first end-to-end implementation on Stable Diffusion 1.5, 2.1, XL, and Flux-dev. With these workarounds, encoding an image on Stable Diffusion 1.5 takes under 10 seconds, and the rate-distortion curves at low ultra-low bitrates are competitive with purpose-built generative codecs such as HiFiC, MS-ILLM, PerCo, and DiffEIC. If the claim holds, today's expensive pretrained diffusion models become reusable zero-shot image compressors whose bitrates improve as the models grow.","feed_headline":"Stable Diffusion becomes a zero-shot lossy image compressor","feed_subtitle":"First full DiffC implementation encodes in under 10 seconds and rivals purpose-built codecs at ultra-low bitrates.","key_machinery":"The load-bearing object is the reverse-channel coding step inside the DiffC protocol. DiffC transmits a sequence of progressively denoised latents, sending each sample $x_t \\sim q(x_t|x_{t+1}, x_0)$ using the receiver's shared model distribution $p_\\theta(x_t|x_{t+1})$, which costs roughly $D_{\\mathrm{KL}}(q\\|p)$ bits per step; the receiver then denoises with probability-flow DDIM sampling to reconstruct the image. The paper makes this practical by exploiting the structure of the Gaussian posterior: when $D_{\\mathrm{KL}}$ per step is too small for bitrate-efficient coding, it skips denoising steps; when too large, it splits the anisotropic Gaussian into independent chunks near a 16-bit sweet spot; and a custom GPU kernel implements the Poisson Functional Representation reverse-channel coder fast enough to make the overhead negligible. A greedy shortest-path optimization over the timestep schedule (Algorithm 3) selects the sequence of steps that minimizes expected bits.","core_discovery":"The central claim is that the DiffC algorithm, previously analyzed only in idealized form, is practically implementable on pretrained latent diffusion models, and that these unmodified models are capable lossy image compressors. The paper's contribution is the first complete DiffC implementation, achieved by stepping over denoising stages when the per-step KL divergence is too small for efficient reverse-channel coding, splitting the high-dimensional Gaussian into independent chunks when the KL is too large, and using a fast custom reverse-channel coding kernel that makes the Poisson Functional Representation an acceptable overhead. The authors report that this practical implementation stays within about 30% of the bitrate of idealized reverse-channel coding at the same PSNR, compresses and decompresses with Stable Diffusion 1.5 in under 10 seconds, and produces rate-distortion and perceptual-quality curves competitive with state-of-the-art generative compression methods at low ultra-low bitrates, despite requiring no training and supporting any target bitrate progressively. Reconstruction fidelity is bounded by each latent diffusion model's autoencoder, with Flux's higher-fidelity VAE (32.4 dB PSNR on Kodak) allowing higher-quality compression than Stable Diffusion 1.5/2.1.","pith_inferences":["Beyond the paper: if the hard-coded DKL and timestep schedules are as robust as the appendix suggests, the same protocol could be ported to a new architecture by recomputing Algorithm 3 once on a small reference set, without per-image tuning.","Beyond the paper: the bitrate gap between the practical and idealized curves sets a concrete research target—a more efficient reverse-channel coder would immediately improve every DiffC codec with no retraining.","Beyond the paper: the same tricks of skipping small-KL steps and splitting Gaussian dimensions should transfer to audio or video latent diffusion models, where pretrained models exist but no DiffC implementation has been demonstrated.","Beyond the paper: the observation that hard-coded KL values below the true divergence cause little distortion suggests the protocol has a built-in robustness margin that a systematic sensitivity study could turn into a formal guarantee."],"forward_implications":["Any pretrained DDPM-class generative model can be turned into a lossy codec with no retraining, so improvements in generative modeling should transfer directly to compression performance.","DiffC is naturally progressive: a single encoder can target any bitrate by stopping the noising process at a chosen timestep, while trained codecs like PerCo or HiFiC need separate training per rate.","The measured gap between the practical and idealized rate-distortion curves quantifies what better reverse-channel coding would buy: closing that gap improves bitrate without any change to the diffusion model.","Flux's higher-fidelity autoencoder shifts DiffC into a higher-quality regime, remaining competitive with HiFiC near 0.46 bits per pixel, whereas Stable Diffusion 1.5/2.1 are best suited to ultra-low bitrates under about 25 dB PSNR.","Prompt conditioning did not pay for its bits on Stable Diffusion 1.5/2.1, and for SDXL and Flux it improved perceived quality but not distortion metrics."],"supporting_citations":[{"why":"Establishes the DDPM compression protocol and the variational likelihood bound that DiffC's bit count is built on.","marker":"Ho et al. (2020)"},{"why":"Defines the DiffC algorithm and its idealized rate-distortion analysis, which this paper implements.","marker":"Theis et al. (2022)"},{"why":"Supplies the Poisson Functional Representation (PFR) algorithm used for reverse-channel coding.","marker":"Theis & Ahmed (2022)"},{"why":"Provides the reference TensorFlow reverse-channel coding implementation whose 140 ms per 16-bit chunk motivates the custom GPU kernel.","marker":"Havasi et al. (2019)"},{"why":"The DDIM scheduler used as the probability-flow denoiser in the reconstruction phase.","marker":"Song et al. (2020)"},{"why":"Defines optimal-transport flow matching, which the paper transforms into DDPM probability paths to run DiffC on Flux-dev.","marker":"Lipman et al. (2022)"},{"why":"PerCo is the primary ultra-low-bitrate conditional-diffusion baseline that DiffC is compared against.","marker":"Careil et al. (2024)"},{"why":"HiFiC is a state-of-the-art generative compression baseline used to benchmark DiffC at higher bitrates.","marker":"Mentzer et al. (2020)"},{"why":"MS-ILLM is a generative compression baseline that DiffC is compared against in the rate-distortion curves.","marker":"Muckley et al. (2023)"}],"fun_headline_variants":["First full DiffC on Stable Diffusion: lossy images in 10s","Pretrained diffusion models compress images without training","DiffC finally implemented: Stable Diffusion as codec","Zero-shot lossy compression with Stable Diffusion models","Ultra-low bitrate images via pretrained diffusion codecs"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The reported bitrates assume that the step schedule and per-step bit budgets, computed by averaging over the very Kodak and Div2K images used for evaluation, are a legitimate pre-established protocol that will perform the same on any new image.","fun_headline_variants_meta":{"raw":{"variants":["First full DiffC on Stable Diffusion: lossy images in 10s","Pretrained diffusion models compress images without training","DiffC finally implemented: Stable Diffusion as codec","Zero-shot lossy compression with Stable Diffusion models","Ultra-low bitrate images via pretrained diffusion codecs"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000178,"raw_usage":{"total_tokens":1278,"prompt_tokens":906,"completion_tokens":372,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":522,"completion_tokens_details":{"reasoning_tokens":292}},"tokens_in":522,"tokens_out":372,"duration_ms":4149,"temperature":1.0,"reasoning_tokens":292,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T19:38:48.746954+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Encode a held-out set of images that were not used to compute Algorithm 3's step schedule or the mean per-step DKL values, using the released protocol; if the rate-distortion curve drops noticeably relative to the reported Kodak/Div2K curves, the zero-shot claim overstates what users will see on new images.","supporting_citations":[{"cited_title":"Algorithms for the communication of samples","cited_arxiv_id":null,"evidence_quote":"Defines the DiffC algorithm and its idealized rate-distortion analysis, which this paper implements."},{"cited_title":"Algorithms for the communication of samples","cited_arxiv_id":null,"evidence_quote":"Supplies the Poisson Functional Representation (PFR) algorithm used for reverse-channel coding."},{"cited_title":"Minimal random code learning: Getting bits back from compressed model parameters","cited_arxiv_id":null,"evidence_quote":"Provides the reference TensorFlow reverse-channel coding implementation whose 140 ms per 16-bit chunk motivates the custom GPU kernel."},{"cited_title":"Muckley, Jakob Verbeek, and St \\'e phane Lathuili \\`e re","cited_arxiv_id":null,"evidence_quote":"PerCo is the primary ultra-low-bitrate conditional-diffusion baseline that DiffC is compared against."},{"cited_title":"Improving statistical fidelity for neural image compression with implicit local likelihood models","cited_arxiv_id":null,"evidence_quote":"MS-ILLM is a generative compression baseline that DiffC is compared against in the rate-distortion curves."}],"review_version":1}