🤖 AI

GETA-3DGS: Automatic Joint Structured Pruning and Quantization for 3D Gaussian Splatting

GETA-3DGS introduces the first end-to-end automatic framework for 3D Gaussian Splatting that jointly optimizes structured pruning and heterogeneous mixed-precision quantization via a novel quantization-aware dependency graph and render-aware saliency metric, achieving significant storage reduction without relying on hand-tuned heuristics or per-scene thresholds.

Original authors: Baobing Zhang, Wanxin Sui

Published 2026-05-06

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Baobing Zhang, Wanxin Sui

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Digital Hoarder"

Imagine you have a beautiful, photorealistic 3D scene of a room or a garden. To make this look perfect on a computer, the software (called 3D Gaussian Splatting or 3DGS) creates millions of tiny, invisible "paint blobs" (Gaussians) floating in space. Each blob has five different properties: where it is, how big it is, how it's rotated, how transparent it is, and what color it is from different angles.

The problem? This "digital hoarder" is messy. A single scene can take up hundreds of megabytes or even gigabytes of space. That's like trying to carry a library in your pocket. If you want to stream this to a phone or an AR glasses, the file is too heavy, and the internet connection is too slow to handle it.

The Old Way: The "Manual Janitor"

Previously, people tried to shrink these files by acting like a manual janitor. They used fixed rules, like:

"If a blob is see-through, delete it."
"If a blob is small, delete it."
"Round all numbers to the nearest 8-bit integer."

The flaw: These rules are rigid. They don't know that a tiny, transparent blob might be crucial for a specific shadow, while a huge, bright blob might be unnecessary. Also, you had to manually tweak these rules for every single scene (a garden needs different rules than a kitchen). It was slow, inconsistent, and often ruined the picture quality.

The New Solution: GETA-3DGS (The "Smart Architect")

The authors propose GETA-3DGS, a system that acts like a smart, automatic architect who knows exactly how to shrink the file without breaking the house. It does two things at the same time (jointly), rather than one after the other:

Pruning (The "Weeding"): It decides which "paint blobs" to throw away.
Quantization (The "Downsizing"): It decides how much detail to keep for the remaining blobs.

Here is how it works, using three creative analogies:

1. The "Menu of Ingredients" (Heterogeneous Quantization)

Imagine you are packing a suitcase.

Old Way: You put everything in the same size box. You might use a giant box for a pair of socks (wasting space) or a tiny box for a heavy coat (crushing it).
GETA-3DGS: It realizes that different "ingredients" need different treatment.
- Position (Where the blob is): This is critical. If you move a blob even a tiny bit, the image looks jittery. So, this gets a high-precision box (lots of bits).
- Opacity (Transparency): This is less critical. It gets a smaller box (fewer bits).
- Color details: Some color details are super important; others are just background noise. The system gives big boxes to the important colors and tiny boxes to the noise.

This is called Heterogeneous Mixed-Precision. It's like packing a suitcase where you use a vacuum bag for clothes but a rigid case for jewelry, rather than putting everything in the same plastic bin.

2. The "Eye-Test" (Render-Aware Saliency)

How does the system know which blobs to keep?

Old Way: It looked at the math inside the computer (like checking the weight of a brick).
GETA-3DGS: It looks at the final picture. It asks: "If I delete this blob, will the human eye notice?"
- It checks if the blob is hidden behind something else (occluded).
- It checks if the blob is contributing to a sharp edge or a shadow.
- It checks how much "screen space" the blob covers.

It's like a photographer looking at a photo and saying, "I can blur out the background trees because no one is looking at them, but I must keep the sharp focus on the person's face."

3. The "Automatic Negotiator" (The Optimization)

The system doesn't just guess. It runs a complex negotiation process (called PPSG) to find the perfect balance.

The Goal: "I need this file to be under 5MB, but it must still look like a 25-star hotel."
The Process: It tries deleting blobs, shrinking numbers, and checking the result. If the picture gets too blurry, it puts a few blobs back or gives them more detail. If the file is too big, it cuts more.
The Result: It finds the "sweet spot" automatically, without a human needing to say, "Hey, make the opacity threshold 0.5."

The Results: What Did They Achieve?

The authors tested this on famous 3D scenes (like gardens, rooms, and train stations).

Storage: They reduced the file size by about 5 times (e.g., from 20MB down to 4MB).
Quality: The picture quality remained very high. In fact, it was much better than trying to just "shrink" the numbers blindly (which caused the picture to look blocky and bad).
Automation: You don't need to tune settings for every scene. You just tell the system, "I want this size," and it figures out the rest.

The "Complementary" Secret

The paper makes a very important point: GETA-3DGS is not the whole story.
Think of 3DGS compression as a three-step assembly line:

Pruning & Quantization (GETA-3DGS): Cutting out the junk and resizing the parts.
Entropy Coding (HAC++, CompGS): Packing those resized parts into the most efficient shipping containers possible.

GETA-3DGS handles Step 1 perfectly. It creates a clean, optimized set of parts. You can then feed those parts into Step 2 (the shipping containers) to get even smaller files. The authors say their method is a "backbone" that makes the other methods work even better, rather than competing with them.

Summary

GETA-3DGS is a smart, automatic tool that shrinks massive 3D scenes by:

Treating different parts of the 3D model with different levels of detail (like packing a suitcase intelligently).
Only keeping the parts that the human eye actually sees.
Doing all this automatically, so you don't have to be a math expert to get a small, high-quality file.

It turns a "digital hoarder" into a "minimalist designer" without losing the beauty of the original scene.

Technical Summary: GETA-3DGS

Problem Statement

3D Gaussian Splatting (3DGS) has established itself as a state-of-the-art method for real-time, photorealistic novel-view synthesis, offering rendering speeds an order of magnitude faster than Neural Radiance Fields (NeRFs). However, high-fidelity 3DGS scenes typically require hundreds of megabytes to multiple gigabytes of storage, creating a deployment bottleneck for mobile, immersive, and volumetric video platforms that demand footprints in the tens of megabytes.

Existing compression strategies for 3DGS generally suffer from three structural limitations:

Isolation of Techniques: Pruning, quantization, and entropy coding are often treated as separate stages, preventing a joint rate–distortion trade-off.
Heuristic Reliance: Methods rely on hand-tuned thresholds (e.g., opacity, scale, or spherical harmonic order) that require manual adjustment per scene, limiting generalization.
Lack of User Control: Users cannot directly specify hard targets for storage size or guaranteed rendering quality bounds.

Furthermore, applying existing joint pruning–quantization frameworks (like GETA for deep networks) to 3DGS is non-trivial because 3DGS lacks a hierarchical computational graph, consists of unordered geometric primitives with heterogeneous attributes, and utilizes a differentiable rasterization loss rather than a standard feed-forward pass.

Methodology: GETA-3DGS

The authors propose GETA-3DGS, the first end-to-end automatic framework for joint structured pruning and mixed-precision quantization tailored specifically to 3DGS. The method reformulates the 3DGS scene as a constrained optimization problem over a heterogeneous parameter space, solved via a white-box optimizer.

1. 3DGS-Aware Quantization-Aware Dependency Graph (QADG)

To adapt the GETA framework to 3DGS, the authors construct a three-level dependency graph:

Level 1 (Prunable Groups): Each Gaussian primitive is treated as a single prunable group. Pruning a group removes the entire row of attributes (position, scale, rotation, opacity, SH coefficients) for that primitive.
Level 2 (Attribute Sub-nodes): Each of the five attribute classes ( $\mu, s, q, \alpha, c$ ) is assigned an independent quantizer. This acknowledges that attributes have different sensitivities (e.g., position requires high precision to avoid jitter, while opacity is bounded by a sigmoid).
Level 3 (SH-Degree Sub-nodes): Spherical Harmonic (SH) coefficients are split into a DC term (diffuse albedo) and AC terms (view-dependent residuals), allowing distinct bit-widths for frequency bands.
Rendering-Order Edges: The graph includes edges weighted by expected transmittance to capture the data-dependent $\alpha$ -blending order, which is crucial for saliency calculation.

2. Render-Aware Saliency

The standard first-order Taylor saliency used in deep learning is unreliable for 3DGS because it can assign high importance to occluded or off-screen primitives due to "ghost gradients" from the rasterizer. GETA-3DGS replaces this with a render-aware saliency that fuses three screen-space signals:

Transmittance-weighted contribution: The actual luminance contribution of the Gaussian to the rendered image.
Screen-space gradient: The magnitude of the gradient with respect to the rendered color, projected through the rendering operator.
Pixel coverage: The number of pixels the Gaussian touches, penalizing small, distant primitives that offer low rate–distortion benefit.
These components are convexly combined to produce a robust importance score for pruning decisions.

3. Heterogeneous Per-Attribute Mixed-Precision Quantization

Instead of a uniform bit-width, the framework assigns independent bit ranges to each attribute and SH degree. The bit-width is controlled by learnable parameters ( $q_m, t, d$ ) optimized via a Projected Partial Saliency-Guided (PPSG) descent. This ensures that the optimization direction remains a descent direction even after projecting onto the sparse and quantized feasible set.

Information-Theoretic Justification: The authors derive a reverse-water-filling analysis showing that the optimal bit allocation depends on the product of the attribute's variance and its rendering sensitivity. Empirical results show the learned bit allocations closely match this theoretical optimum.

4. Four-Stage Training Schedule

To ensure stability, the training follows a four-stage schedule:

Warm-up: Standard 3DGS training to establish a high-fidelity overcomplete scene.
Projection: The heterogeneous quantizer is enabled, and bit-width upper bounds are linearly contracted toward targets.
Joint: Structural pruning and bit-width fine-tuning occur concurrently. A hard PSNR floor constraint is enforced; if pruning a Gaussian drops the PSNR below a user-specified threshold $\tau$ , the pruning is relaxed to preserve quality.
Cool-down: Structure and bit-widths are frozen, and only the quantized attributes are fine-tuned to recover residual distortion.

Key Contributions

Automatic Framework: GETA-3DGS is the first end-to-end automatic pipeline for joint pruning and quantization in 3DGS, eliminating the need for per-scene manual tuning of opacity, scale, or SH-degree thresholds.
3DGS-Aware Architecture: The introduction of the QADG and render-aware saliency specifically addresses the geometric and rendering-driven nature of 3DGS, overcoming the limitations of applying deep learning compression techniques directly.
Heterogeneous Quantization: The paper demonstrates that heterogeneous per-attribute bit allocation is the dominant lever for rate–distortion performance. Forcing a uniform 6-bit cap results in significant quality loss (up to -6.74 dB on view-dependent scenes) compared to the proposed heterogeneous allocation.
Complementarity: The authors position their work as a backbone (axes of pruning and quantization) that is complementary to downstream entropy coders (axis of coding), rather than a competing solution.

Experimental Results

Evaluated on Mip-NeRF 360, Tanks and Temples, and Deep Blending:

Storage Reduction: GETA-3DGS achieves approximately 5 $\times$ storage reduction over Vanilla 3DGS (e.g., reducing Mip-NeRF 360 scenes from ~20 MB to ~4.86 MB).
Quality vs. Baselines:
- It outperforms a naive sequential "prune-then-quantize" baseline by +4.24 dB to +8.35 dB at matched storage sizes.
- While the absolute PSNR of GETA-3DGS is lower than entropy-coded codecs like HAC++ (which operate on a different axis), the paper argues that GETA-3DGS provides the necessary automatic backbone upon which such codecs can be layered.
Ablation Studies: The study confirms that the bit-width policy (heterogeneous vs. uniform) is the most critical component. Removing heterogeneity and forcing a uniform 6-bit grid causes an average drop of -2.18 dB, with severe penalties on view-dependent scenes.

Significance and Claims

The paper claims that GETA-3DGS establishes a new paradigm for 3DGS compression by shifting from heuristic, manual tuning to an automatic, user-controlled optimization process.

User Control: Users can specify a target storage budget or a minimum PSNR floor, and the system automatically traces the rate–distortion curve to find the optimal operating point.
Modularity: The framework is designed to be a "complementary axis" to existing codecs. It handles the structural sparsity and mixed-precision quantization, leaving the entropy coding to downstream modules.
Engineering Value: By abstracting the compression problem into a QADG topology, the framework reduces the engineering cost of adapting compression to new 3DGS variants (e.g., dynamic or hierarchical 3DGS) from weeks of hyperparameter tuning to minimal integration effort.

The authors modestly acknowledge that their current prototype uses a generic symmetric quantizer without anchor-based context modeling, which accounts for the remaining PSNR gap compared to state-of-the-art entropy-coded methods. They propose that future work integrating anchor-based context models and hash-grid entropy coding on top of the GETA-3DGS backbone could close this gap.