acceptodds
Under review as a conference paper at ICLR 2027

Predicting Compression Gains Before Encoding: Attribute Models for 2D Gaussian Images

Abstract

Gaussian image representations, which encode an image as a set of 2D Gaussians, have become a practical representation for image compression. Compressing this set involves two interlinked design choices: the spatial organization of the Gaussians and the probability model for their attributes. Such choices are typically made empirically, by building candidate coders and comparing total file size. A controlled study of lossless coding of quantized Gaussian sets shows that this practice can mislead: among the structures tested, a quadtree hierarchy codes positions most compactly, yet loses overall because of the attribute model paired with it. We therefore propose a predict-before-encoding protocol: it measures, on a selection split, whether the information a quadtree cell carries about each attribute outweighs the cost of learning a separate model per cell, and fixes the answer before any evaluation image is encoded. In a prospective study on GaussianImage representations, the predicted gain over conditioning every attribute, 1.414 bits per Gaussian, closely matches the realized gain of 1.361, and the protocol also correctly forecast the one comparison the chosen coder loses.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Gaussian Splatting, Image Compression, Entropy Coding, Information Theory, Minimum Description Length, Adaptive Coding

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_3xEDOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

This paper addresses how to entropy-code the attributes in 2D Gaussian image representation compression. Specifically, for each attribute (scale, rotation, opacity, and color), it decides between (i) dividing the image into 16 fixed cells and using a separate probability model for each cell (per-cell), or (ii) using a single probability model for the whole image (global). This decision is made on 20 images and then fixed, so it does not change with the input image. Based on the decision, for scale and color attributes, per-cell models are chosen, and global models for rotation and opacity. This approach saves 0.526 bits/G of attribute bits compared with using global models for all attributes, and 0.190 bits/G compared with using per-cell models for all attributes (Table 4).

Critical strengths

None

Critical weaknesses

W1: The study in this paper is confined to one specific setting in which many design choices are fixed arbitrarily. Positions are coded by a quadtree, the image is divided into a fixed 4×4 cell grid, and only two attribute models (global or per-cell) are considered. Within this setting, the method only decides which of the two models to use for each attribute. Such a binary decision rule for each attribute is difficult to recognize as a research contribution.

W2: The paper claims three contributions in the Introduction:

  • a controlled study,

  • a predict-before-encoding protocol, and

  • validation.

However, none of them offers a new perspective or a technical advance over existing work. The predict-before-encoding decision rule is classical MDL accounting, as the authors acknowledge (Section 4), and validating a decision on held-out data is standard practice in machine learning. Rather, an improvement in rate efficiency of entropy coding could be a clear contribution, but the proposed method is reported to perform worse than even the general-purpose compressor xz (Section 6.3). The authors state that “absolute rate is not the claim” (line 426). However, the value of this work beyond coding efficiency is unclear.

Questions for authors

There are no questions that I expect to change my assessment. However, if my understanding of the paper’s core contribution is substantially mistaken, active discussion during the rebuttal is strongly encouraged.

6 comments
AuthorsOpenReview ↗

Response to Reviewer 3xED

Thank you for the review. Both points led to concrete changes in the revision, which we summarize below.

W1: one fixed setting and a binary choice. The revised method selects, per image, one of five quadtree context depths (from one global model to 256 cells) for each of scale, rotation and color, so the fixed 4×4 grid and the binary choice are gone. The selection is made before encoding, from symbol counts. On all 305 encoded sets in 11 cohorts from three Gaussian producers and three datasets, it reaches the same size as encoding all 125 depth combinations and keeping the smallest. The quadtree position coder is still fixed; the paper is about attribute context selection, and we state that scope in the introduction.

W2a: MDL and held-out validation are standard. We agree that the accounting is MDL. The point of the paper is which codelength to use. Standard held-out validation (in our case: fit on four fifths of each image, score the rest) predicts the wrong sign of the gain for rotation, because it leaves out the cost of learning from empty counts that the coder pays within each image. The sequential codelength under the coder's own update rule predicts the mean measured change to within 0.003 bits/G. So in this setting, the standard practice gives the wrong decision and the sequential one gives the right one. The revised paper puts this comparison in the main text.

W2b: worse than xz. Following up on this point, we found that the submitted container, not the probability model, caused the gap. It closed a separate rANS stream every 256 symbols and wrote a header and directory entry for each tile and attribute group. On small Gaussian sets this framing dominated the file: over 100 bits per Gaussian on Kodak images with about 1,000 Gaussians. The probability model itself already used fewer bits than xz on the attribute columns in every cohort. We changed only the container (a header of 49–51 bytes, one rANS stream for positions, one for attributes, a CRC); the models and the selection rule are unchanged, and every file was decoded in a separate process and matched the input byte for byte. Complete files, bits per Gaussian, compared with the smaller of xz and zstd for each image (95% bootstrap CI over images):

CohortNOursBest of xz / zstdSavings % [95% CI]W/T/L
DIV2K selection (AIR)176k64.1869.207.2 [6.4, 8.0]20/0/0
DIV2K held-out (AIR)178k63.9668.826.9 [6.3, 7.5]77/0/3
CLIC validation (AIR)177k61.6665.515.4 [3.2, 7.1]26/0/3
GaussianImage, N = 5k5k75.3979.795.5 [5.2, 5.8]20/0/0
GaussianImage, N = 10k10k73.5278.386.2 [5.9, 6.5]20/0/0
GaussianImage, N = 20k20k72.0877.476.9 [6.5, 7.3]20/0/0
GaussianImage, N = 40k40k70.6776.858.0 [7.6, 8.4]20/0/0
GaussianImage++ Kodak, low density, mid quantizer98662.2569.039.8 [9.1, 10.5]24/0/0
GaussianImage++ Kodak, low density, high quantizer98675.1783.489.9 [9.4, 10.4]24/0/0
GaussianImage++ Kodak, high density, mid quantizer4.8k56.7762.018.4 [8.0, 8.9]24/0/0
GaussianImage++ Kodak, high density, high quantizer4.8k68.3074.027.7 [7.5, 8.0]24/0/0

N is the mean number of Gaussians per image. The file is smaller than both general-purpose compressors on 299 of 305 sets. On the six remaining sets, all AIR images with 52k–94k Gaussians, our file is 0.02% to 11.0% larger than xz; the revised appendix lists them with the size of each segment. We do not claim that this beats learned or specialized coders; xz and zstd are the only baselines here, and we state this as a limitation. The sentence "absolute rate is not the claim" is removed, and the old container results are kept in the appendix.

Reviewer_3xEDOpenReview ↗

Response to Authors

Thank you for the detailed response. I understand that the revision modifies the method, corrects the error in the rate evaluation, and extends the experiments.

However, the core research value claimed by this paper remains unclear to me. In the original submission, the authors stated that "absolute rate is not the claim," and this sentence has now been removed. If the contribution is now the coding efficiency itself, it should be supported by comparisons with learned or specialized entropy coders for Gaussian attributes. Outperforming general-purpose compressors such as xz and zstd by 5–10% is not sufficient to establish this.

Therefore, I maintain my rating.

Thank you for the follow-up. The claim has not changed. The contribution is the decision made before encoding: how much spatial context each attribute should use, and which estimate selects it correctly. The held-out estimate gets the sign wrong for rotation; the sequential codelength under the coder's own update rule selects the same route as exhaustive encoding of all 125 routes on all 305 sets. This is measured against the coder's own exhaustive search, not against other coders.

We removed "absolute rate is not the claim" because it was written to explain a loss to xz caused by container framing, which the revision fixed; the claim did not move to absolute rate. The xz/zstd comparison only shows that the decision is studied on a reasonable coder, and the paper states that we compare only with general-purpose compressors.

Learned entropy models such as HAC, ContextGS and LG-HCC also fix their context structure in advance. A rate comparison with them would mainly compare model families, which we keep fixed on purpose so that the effect of the context choice can be measured exactly.

Reviewer_jXVnOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies lossless coding of the quantized 2D Gaussian image representations. The main idea is to separate spatial organization from attribute modeling and shows that a quadtree’s position savings can be outweighed by a poor matched attribute model. From this observation, the paper presents a predict-before-encoding protocol for selecting global or spatially conditioned attribute models before entropy coding of quantized Gaussians on 20 selection images. The numerical experiments evaluate this frozen choice on held-out images and test count-based codelength forecasts on Gaussians from other fitting methods.

Critical strengths

The paper's experiments are careful and extensive, isolating the attribute model from geometry and the coding setting.

Rather than being based on entropy coding only, the paper's evaluation considers the complete-file measurements to make the strength results. In addition, the experiments show the improvement of the mean attribute rate over both uniform choices.

Critical weaknesses

The proposed method evaluates performance across images while the coder learns within each image. These procedures incur different learning costs. The paper should better explain why these estimates guide the coding decision reliably.

The internal gains are supported but small, and the paper does not quantify forecasting runtime or its savings over evaluating candidate model costs without producing bitstreams.

Questions for authors

Why is depth-4 profitability an appropriate requirement for a depth-2 coder? How much computation does forecasting save over evaluating candidate probability models?

1 comment
AuthorsOpenReview ↗

Response to Reviewer jXVn

Thank you for the review. Your first weakness identified the most important technical point, and we rewrote the method around it.

W1: estimates across images vs learning within an image. We agree that these have different learning costs, and in our data the difference matters. The cross-fitted estimate of the submitted version, which fits the model on four fifths of each image and scores the remaining fifth, treats the model as already trained and predicts the wrong sign of the gain for rotation. The revised score instead replays the coder's own sequential learning rule on the symbols of the image being coded: each symbol is charged the probability the adaptive model would assign at that point, with the same block-wise updates. This is the codelength the coder pays, up to the entropy coder's rounding. It matches the mean measured change to within 0.003 bits/G, and the routes it selects reach the same size as exhaustive search over all 125 depth combinations on all 305 encoded sets in 11 cohorts.

W2: small gains and missing runtime. Runtime under the revised container, on 15 cases, single thread, one warm-up and three timed runs; we report the range over cases of the per-case median:

AIR (5 images, N = 116k–207k)GaussianImage (10 sets, N = 5k–10k)
Count-based selection (all 125 routes)27–37 s2.3–4.4 s
Evaluating each candidate model350–552 s10–31 s
Trial encoding of all 125 routes134–200 s6.9–17 s
One final encoding pass52–78 s2.2–6.1 s
Decoding160–220 s8.0–22 s
xz / zstd compression1.8–3.6 s0.07–0.20 s

Per case, selection is 12–15× faster than evaluating the candidate models and 4.8–5.4× faster than trial encoding on AIR (4.4–7.2× and 3.0–4.0× on the small sets), and all three choose the same route. Two points we state plainly in the revision. First, selection is not cheap relative to encoding: it takes 41–59% of one encoding pass on AIR and 68–104% on the small sets. Second, our decoder is about three times slower than our encoder; about 90% of decoding time is in the position decoder, which rebuilds each probability table instead of caching it as the encoder does. Both coders are single-threaded Python and much slower than xz and zstd. The machine was shared during these runs, and the logged load was high for the first two AIR cases; an earlier run of the same selection code took 16–28 s, but we did not record the load during that run. We report the slower numbers.

On the size of the gains, measured on complete files with 95% bootstrap CIs over images:

  • Against global coding (one model per attribute), per-image selection saves 1.0–2.0% on the three AIR cohorts and 0.2–2.2% on GaussianImage++; on GaussianImage it chooses global coding for almost every image, so the saving is 0.00–0.01%.
  • Against the fixed route of the original paper, it saves 0.27–0.33% on AIR, 2.0–4.2% on GaussianImage++, and 3.8–7.2% on GaussianImage.
  • Against the best single fixed route chosen in hindsight for each cohort, it saves only 0–0.26%.

So within one producer the gain is small. The useful effect is that the best fixed route changes with the producer, and selection finds it per image without knowing the producer.

Q: Why depth-4 profitability for a depth-2 coder? It was a conservative proxy in the original protocol: it only allowed per-cell coding when even finer cells were profitable. It was hard to justify, and the revised method removes it. Each depth from 0 to 4 is now scored directly with the same sequential codelength, so no proxy depth is needed.

The revision also introduces a leaner container, with which the coder is smaller than xz and zstd in every cohort; please see the general response, point 4.

Reviewer_abe9OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents a comprehensive study of the lossless entropy coding of quantized 2D Gaussian image representations, and demonstrates that the design choice of the probability model for each attribute determines the compression performance. Based on this analysis, it proposes a predict-before-encoding protocol that decides whether to use a global or a per-cell probability model for each attribute. In the experiments, the proposed hybrid design is compared with alternative entropy coding strategies on 2D Gaussian representations fitted by existing 2D Gaussian image reconstruction methods (AIR, GaussianImage, GaussianImage++) to standard image benchmarks (DIV2K, Kodak).

Critical strengths
  • The paper addresses the trade-off of using spatial context in attribute modeling for lossless Gaussian coding, an aspect that has been less focused on prior Gaussian compression studies. Specifically, it clearly separates the effects of spatial contexts in attribute modeling by comparing the global and per-cell models, providing a more interpretable analysis that helps to identify where the compression gains and overheads come from.
  • It conducts a comprehensive study on various entropy coding strategies and provides extensive empirical verification across 2D Gaussian sets obtained from representative image reconstruction methods, including AIR and GaussianImage variants, on standard 2D image benchmarks, including DIV2K and Kodak.
Critical weaknesses

The contribution of this paper seems not suitable for an ML conference, since it is closer to a comprehensive analysis than to a method proposing a fundamentally novel machine learning algorithm or representation.

  • Specifically, most of the content focuses on selecting between global and per-cell entropy coding for each attribute, rather than proposing a novel entropy coding method. Although the paper proposes a decision protocol, the decision space is limited to choosing between a per-cell and a global model for each attribute, and the selected route is shared across all images. This is too limited to be a significant contribution.
  • To better fit this conference, the paper would need a stronger technical contribution, such as an effective learned model that adaptively predicts the coding strategy for each input representation rather than relying on fixed global/per-cell choices, or an extension of the current binary decision protocol to a broader design space that includes other factors such as spatial granularity (e.g., quadtree depth).
Questions for authors
  • Can the decision protocol be extended to broader setup, rather than only choosing between global and per-cell models at a predefined depth? It could be helpful to clarify whether the proposed framework can generalize beyond the current decision space.
  • Why should a single frozen route be applied uniformly across different input images? Since each image contains different content, the attribute distributions can vary considerably across images, and the optimal route can therefore differ for each input. Adaptively selecting the route for each input 2D Gaussian image representation seems to be a more optimal solution. Please correct me if I have misunderstood this point.
3 comments
AuthorsOpenReview ↗

Response to Reviewer abe9

Thank you for the review. Your two questions point directly to the main extension in the revision.

Q1: Can the protocol go beyond global vs per-cell at one depth? Yes. The revised method chooses, for each attribute group, one of five quadtree depths (0 to 4). The same count-based score applies to every depth, so the decision space is no longer binary. Across producers the chosen depths differ in a consistent way: on AIR, scale mostly uses depth 1 and color often uses depth 2; on GaussianImage almost every attribute uses depth 0; on GaussianImage++ color mostly uses depth 1. Opacity is fixed to the global model in all cases. Figure 2 of the revision shows that the choice follows the number of Gaussians per cell, which is the trade-off the paper studies.

Q2: Why one frozen route for all images? The revised method selects the depths per image, before encoding, at a cost of 27–37 s on images with 116k–207k Gaussians (41–59% of one encoding pass; timing details are in the reply to jXVn). The data show why a single route is a problem: on GaussianImage, where the best choice is global coding, per-image selection is 6.0% smaller than the route of the original paper, which was chosen on AIR. Within any one producer, a well-chosen fixed route is close to per-image selection (0–0.26%), so the gain comes from not having to know the producer in advance.

On a learned predictor. We considered training a model to predict the route. Under the revised single-stream container, the count-based selection already reaches the same size as exhaustive search over all 125 depth combinations on every image we tested (305 encoded sets in 11 cohorts). This is largely by construction, since the score is the coder's sequential codelength under its own frequency tables, computed without the entropy coder. A learned predictor therefore cannot reduce the rate further; it could only reduce selection time, which is 41–59% of one encoding pass on large images and close to one full pass on small ones, so this is a real but secondary cost. We agree that a learned model would be the natural next step if the candidate space became too large to score exhaustively, for example with many more context types than depths.

On fit to an ML venue. The central result is about model selection for a learner that adapts within one sample. The standard held-out (cross-fitted) estimate predicts the wrong sign for rotation, while the sequential (prequential) codelength under the coder's own update rule predicts the mean measured change to within 0.003 bits/G. We think this distinction between held-out validation and sequential codelength is relevant to ICLR beyond Gaussian coding, and the revised introduction states it directly.

The revision also introduces a leaner container, with which the coder is smaller than xz and zstd in every cohort; please see the general response, point 4.

Thank you for the detailed responses. In particular, I appreciate that the authors extended the decision space to quadtree depths and the selection to per-image routes, as I suggested.

However, its performance gain remains limited, even though the proposed method operates only within the specific encoding system selected by the authors. In addition, the method is closer to an application of a classical decision protocol to Gaussian image compression since it does not propose a learned model for route selection. Therefore, I still think that this paper does not seem to fit an ML conference.

Recently, various compression methods for Gaussian representations have been built on learned context models. Compared with them, I find the contribution of this paper limited. Therefore, I will maintain my rating.

Thank you for the follow-up and for your suggestions, which shaped the per-image selection in the revision. We understand your assessment. Testing the selection rule inside learned context models is a natural next step, and we will pursue it.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response: summary of revisions

We thank the reviewers for their constructive comments. The reviews raised three main points: (1) whether the choice can go beyond a binary global/per-cell decision with one route shared across images; (2) why the selection score should predict what the coder actually does; (3) how the coder compares with general-purpose compressors such as xz. We extended the method and the experiments to address all three. The revised PDF will be uploaded by November 13; changes are marked in blue.

1. Per-image, per-attribute selection over five context depths. For each image, the revised method selects one of five quadtree context depths (depth 0 = one global model, depth 4 = 256 cells) for each of scale, rotation and color; opacity is fixed to the global model. This gives 5³ = 125 candidate routes per image. The fixed route from the original paper is kept only as a baseline. That route was chosen on AIR; on GaussianImage the per-image selection is 6.0% smaller than it (complete files, 95% CI 5.5–6.4%), and 4.6% smaller than the best fixed route re-selected on AIR for the revision.

2. The score uses the coder's own sequential learning rule. The score of a depth is the codelength that the adaptive coder would pay, computed from symbol counts in the coder's own order, without running the entropy coder. We compare it with the standard alternative, a cross-fitted (held-out) estimate. It predicts the wrong sign of the gain for rotation, because it fits the model on four fifths of an image and scores the rest, so it leaves out the coder's cost of learning from empty counts. The sequential score matches the mean measured change to within 0.003 bits/G.

3. The selection matches exhaustive search. We encoded every image with all 125 routes and kept the smallest attribute stream. The routes chosen from counts reach exactly the same size on all 305 encoded sets in 11 cohorts (two DIV2K splits and CLIC validation with AIR, GaussianImage at four budgets, GaussianImage++ on Kodak at four settings). This follows from the design: under a single rANS stream, the actual size is the sequential codelength plus a small residual (−7 to 229 bits for the selected routes over all 305 sets), so the score and the real size rank the routes the same way. The practical value is that the decision needs no entropy coding pass. On AIR images, selection is about 5× faster than trial encoding all 125 routes (timing in the reply to jXVn).

4. A leaner container. Analysing the comparison with xz showed that the submitted container spent most of its bytes on framing at small sizes: every 256 symbols were closed as a separate rANS stream, and each tile and attribute group had its own chunk header and directory entry. On a Kodak image with 973 Gaussians this framing was over 100 bits per Gaussian. We redesigned only the container: the file is now a header of 49–51 bytes, one rANS stream for positions, one for attributes, and a CRC. The probability models and the selection rule are unchanged, and all 3,601 files were decoded in a separate process and matched the input byte for byte. With the new container, the complete file is smaller than the better of xz and zstd in every cohort, by 5.4–9.9% on average, and on 299 of the 305 sets. The six losses are AIR images with 52k–94k Gaussians, where our file is 0.02% to 11.0% larger than xz; the appendix lists them, together with all results of the old container.

Scope, as stated in the revision. (a) Within one cohort, per-image selection is only 0–0.26% smaller than the best single fixed route for that cohort. Its benefit is that this best fixed route differs between producers (a depth-1 scale / depth-2 color route on AIR, the global model on GaussianImage, depth-1 color on GaussianImage++), and each of the five fixed routes in our comparison is at least 2% larger than the selection on some cohort. Per-image selection removes the need to know the producer in advance. (b) We compare against general-purpose compressors only; we have not compared against learned entropy models or the compression pipelines of other Gaussian representations. (c) The position coder is fixed, and we do not measure how the lossless stage affects the rate-distortion of the full image codec. (d) Our decoder is slow: 160–220 s on AIR images, about three times the encoding time. About 90% of it is in the position decoder, which rebuilds each probability table instead of caching it as the encoder does. This is an implementation issue, not a property of the method. (e) The container change is an engineering improvement, not a contribution of the method. These points are in the limitations section of the revised paper.

With the sequential score, the depth-4 profitability Gate of the original paper is no longer needed and has been removed, as has the sentence "absolute rate is not the claim".

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.