DropAnSH-GS: Regularization in Sparse 3DGS

• The paper introduces anchor-based dropout and SH-degree dropout to mitigate neighbor compensation and over-parameterization in sparse-view 3DGS.
• It employs spatial autocorrelation via Moran’s I to identify redundancy, enabling the removal of clustered Gaussians to enhance rendering quality.
• Empirical results across LLFF, MipNeRF-360, and Blender demonstrate improved PSNR, SSIM, and LPIPS with minimal computational overhead.

DropAnSH-GS is a structured regularization scheme for sparse-view 3D Gaussian Splatting (3DGS) that simultaneously drops spatially correlated clusters of Gaussians via anchor-based removal and drops high-degree spherical harmonics (SH) color components. It is introduced to address two failure modes of sparse-view 3DGS: the neighbor compensation effect in standard opacity dropout, and overfitting induced by high-degree SH under limited viewpoints. The method is designed to be simple to integrate, adds negligible overhead, and enables post-training SH truncation for compression while improving reconstruction quality across LLFF, MipNeRF-360, and Blender (Fang et al., 24 Feb 2026).

1. Problem setting and motivation

Sparse-view 3DGS is vulnerable to overfitting because Gaussian contributions are locally correlated in both opacity and appearance. In standard 3DGS dropout methods, Gaussians are randomly nullified independently. The central critique underlying DropAnSH-GS is that this independent removal is often neutralized by neighboring Gaussians with overlapping kernels and correlated colors or opacities. The paper terms this the neighbor compensation effect: when one Gaussian is removed, nearby Gaussians can absorb the missing contribution through overlap and increased transmittance, making the rendered color change $\Delta C(p)$ small and weakening the intended regularization (Fang et al., 24 Feb 2026).

The rendering formulation used to motivate this effect is the standard 3DGS compositing model. For a pixel $p$,

$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$

with

$$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$

and

$T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$

Dropping a single Gaussian $k$ sets $o_k \leftarrow 0$, but if neighbors satisfy conditions such as $\Sigma_{i,2D} \approx \Sigma_{k,2D}$, $\pi(\mu_i)\approx \pi(\mu_k)$, $o_i\approx o_k$, and $p$0, the lost contribution can be compensated by other splats (Fang et al., 24 Feb 2026).

To quantify local redundancy, the method uses spatial autocorrelation via Moran’s $p$1 for a per-Gaussian attribute $p$2:

$p$3

where $p$4 decays with 3D or screen-space distance and $p$5. Empirically, $p$6 is high at short distances, indicating that opacity and color are strongly correlated among neighbors. This is the direct motivation for replacing independent dropout with cluster-wise removal (Fang et al., 24 Feb 2026).

A second motivation concerns view-dependent color. In 3DGS, per-Gaussian color is represented with SH up to degree $p$7:

$p$8

The number of color parameters is $p$9 per Gaussian. With limited viewpoints, high-degree SH can memorize view-specific appearance and boundaries, which the paper characterizes as over-parameterization that degrades generalization and inflates model size (Fang et al., 24 Feb 2026).

2. Methodological core

DropAnSH-GS combines two coupled regularizers: anchor-based dropout in geometry-opacity space and SH-degree dropout in color space.

The anchor-based dropout mechanism does not drop Gaussians independently. Instead, at each iteration, the method samples anchors $C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$0 with independent Bernoulli$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$1, defines a neighbor set around each anchor, and removes both the anchors and their local neighbors. The neighbor set can be either $C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$2-nearest neighbors in 3D,

$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$3

or a 3D radius set,

$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$4

The total dropout set is

$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$5

and the method applies

$C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$6

Equivalently, a binary mask $C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$7 defines the effective opacity $C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$8. Because spatially adjacent Gaussians that would otherwise compensate for one another are removed together, this structured dropout creates information voids and reduces local redundancy (Fang et al., 24 Feb 2026).

The SH-degree dropout mechanism targets high-degree SH while keeping lower-degree components active. The paper describes two forms. One is a deterministic degree cap: keep degrees up to $C(p) = \sum_i T_i(p)\, w_i(p)\, c_i(\omega_p),$9 and zero all coefficients with $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$0. The other is degree-wise probabilistic masking with a Bernoulli variable $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$1 whose keep probability decreases with $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$2. The implementation used in the paper employs a simple deterministic schedule together with a per-Gaussian probability $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$3 selecting which Gaussians undergo SH truncation at a given iteration (Fang et al., 24 Feb 2026).

The joint rationale is explicit. Anchor-based dropout reduces local compensation by removing clusters, enforcing reliance on broader context and consistent geometry. SH-degree dropout limits over-parameterized view dependence, focuses learning into low-degree SH, and makes the learned appearance robust to post-training truncation. This suggests that DropAnSH-GS is not merely a regularizer for training stability; it is also a mechanism for shaping the representation so that deployment-time compression is less destructive (Fang et al., 24 Feb 2026).

3. Rendering model, optimization, and schedules

DropAnSH-GS is built on the standard 3DGS rendering and training pipeline. A 3D Gaussian $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$4 has mean $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$5, covariance $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$6, and opacity $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$7. Projecting to the screen yields $$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$8 and the representative contribution weight

$$w_i(p) = o_i \exp\!\left(-\frac{1}{2}(p-\pi(\mu_i))^\top \Sigma_{i,2D}^{-1}(p-\pi(\mu_i))\right),$$9

With depth sorting,

$T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$0

The SH appearance model remains

$T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$1

DropAnSH-GS does not alter this renderer fundamentally; it inserts ephemeral opacity and SH masks before compositing (Fang et al., 24 Feb 2026).

The loss follows standard 3DGS practice:

$T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$2

with the paper keeping the original per-dataset setup from 3DGS and not introducing extra regularizers (Fang et al., 24 Feb 2026).

The reported training schedule is specific. The anchor probability $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$3 is linearly ramped from $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$4 to $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$5 over 10k iterations. The neighbor count is $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$6 using 3D $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$7-NN. The SH-drop probability is $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$8. The deterministic SH schedule is coarse-to-fine:

• $T_i(p) = \prod_{j<i} (1-\alpha_j(p)).$9 at 2k iterations,
• $k$0 at 4k iterations,
• $k$1 at 6k iterations,
• training continues to 10k iterations (Fang et al., 24 Feb 2026).

Sensitivity analysis on LLFF with 3 views identifies effective ranges: $k$2–$k$3, $k$4–$k$5, and $k$6–$k$7. The stated interpretation is that values that are too small weaken regularization, while overly aggressive values harm geometry and convergence (Fang et al., 24 Feb 2026).

The per-iteration loop is straightforward. A mini-batch of rays or pixels is sampled; anchors are drawn via Bernoulli$k$8; neighbors are queried; the opacity mask is applied; SH truncation is applied to selected Gaussians; a forward render produces $k$9; the loss is backpropagated; and all masks are restored for the next iteration. The parameters themselves persist, while masking is temporary (Fang et al., 24 Feb 2026).

4. Integration into 3DGS systems

A notable feature of DropAnSH-GS is that it does not require changes to the renderer’s kernels other than reading masked opacities and colors. The method requires only three additional components: a per-iteration binary opacity mask $o_k \leftarrow 0$0, a per-iteration SH mask zeroing high-degree coefficients, and a fast neighbor search backend over Gaussian means $o_k \leftarrow 0$1 (Fang et al., 24 Feb 2026).

The implementation guidance is correspondingly minimal. Neighbor search can use a GPU cell grid or hash-based index, or CUDA $o_k \leftarrow 0$2-NN. The method maintains mask buffers on GPU, computes $o_k \leftarrow 0$3 before the forward pass, and applies degree masks directly to $o_k \leftarrow 0$4. The same masks are reused across all rays in a batch, and the spatial index may be reused or updated every $o_k \leftarrow 0$5 iterations. The implementation is described as using PyTorch, with efficiency references to CUDA $o_k \leftarrow 0$6-NN (Fang et al., 24 Feb 2026).

Because the method only inserts masks and does not alter optimization logic, it can be plugged into multiple 3DGS derivatives, including Scaffold-GS, FSGS, CoR-GS, and DNGaussian, without modifying their optimization logic, background handling, or pose and geometry modules. For motion or dynamic scenes, anchors and neighbors are applied per time slice; for unbounded scenes, scene-space tiling is recommended for neighbor search (Fang et al., 24 Feb 2026).

This integration profile has methodological significance. A plausible implication is that the contribution of DropAnSH-GS is primarily algorithmic rather than architectural: it reconfigures training-time regularization within an otherwise standard sparse-view Gaussian splatting stack. That framing is consistent with the reported negligible overhead and broad compatibility (Fang et al., 24 Feb 2026).

5. Empirical performance and ablations

The experiments cover LLFF with 3/6/9 views, MipNeRF-360 with 12 views, and Blender with 8 views. Baselines include NeRF-style sparse-view methods such as Mip-NeRF, DietNeRF, RegNeRF, and FreeNeRF; 3DGS variants such as 3DGS, DNGaussian, FSGS, and CoR-GS; and dropout baselines such as DropoutGS and DropGaussian. Metrics are PSNR, SSIM, and LPIPS, and results for randomized methods are reported as averages over 3 runs (Fang et al., 24 Feb 2026).

On LLFF with 3 views, DropAnSH-GS reports 20.68 PSNR, 0.724 SSIM, 0.194 LPIPS, compared with DropGaussian 20.33/0.709/0.201 and CoR-GS 20.36/0.710/0.202. The paper states that gains persist at 6 and 9 views, with 26.24 PSNR at 9 views (Fang et al., 24 Feb 2026).

On MipNeRF-360 with 12 views, the compressed variant Ours-SH2 reports 19.95 PSNR, 0.576 SSIM, 0.363 LPIPS with 81.1 MB, compared with DropGaussian 19.66 PSNR, 0.569 SSIM, 0.374 LPIPS at 120.7 MB (Fang et al., 24 Feb 2026).

On Blender with 8 views, Ours-SH3 reports 25.50 PSNR, 0.891 SSIM, 0.088 LPIPS, compared with DropGaussian 25.17/0.882/0.100 (Fang et al., 24 Feb 2026).

The paper also reports runtime overhead relative to vanilla 3DGS:

• LLFF 3 views: 760.2 s vs 741.6 s (+2.5%)
• Blender 8 views: 887.7 s vs 863.3 s (+2.8%)
• MipNeRF-360 12 views: 1114.8 s vs 1083.2 s (+2.9%) (Fang et al., 24 Feb 2026)

These figures ground the claim of negligible computational overhead. The same section states that gains such as +1.5–2.3 dB PSNR outweigh the small cost (Fang et al., 24 Feb 2026).

The ablation study isolates the contribution of each component. On LLFF with 3 views, Drop Anchor alone yields 20.47 PSNR, Drop SH alone yields 19.59 PSNR, and the full method yields 20.68 PSNR, supporting the claim of complementarity between the two mechanisms. On Blender with 8 views, drop by degree outperforms random coefficient dropout, with 25.50 vs 25.12 PSNR (Fang et al., 24 Feb 2026).

Qualitative analysis emphasizes that anchor-based removal eliminates contiguous regions, prevents neighbor compensation, and suppresses Gaussian-shaped artifacts near boundaries and background. The reported interpretation is that reconstructions retain more coherent structure and fewer distortions than under per-Gaussian dropout (Fang et al., 24 Feb 2026).

6. Compression, limitations, and practical guidance

A distinctive aspect of DropAnSH-GS is that the SH-degree dropout used during training doubles as preparation for post-training model compression. After training, SH can be truncated globally to degree $o_k \leftarrow 0$7 by setting

$o_k \leftarrow 0$8

Because training concentrates appearance information into low-degree SH, the model is designed to remain robust under such truncation (Fang et al., 24 Feb 2026).

The parameter-count reduction is explicit. Per Gaussian, color parameters decrease from

$o_k \leftarrow 0$9

to

$\Sigma_{i,2D} \approx \Sigma_{k,2D}$0

Memory therefore scales linearly with the number of Gaussians and quadratically with SH degree. The reported trade-offs on MipNeRF-360 with 12 views are:

• $\Sigma_{i,2D} \approx \Sigma_{k,2D}$1: PSNR 19.71, size 33.8 MB
• $\Sigma_{i,2D} \approx \Sigma_{k,2D}$2: PSNR 19.86, size 51.8 MB
• $\Sigma_{i,2D} \approx \Sigma_{k,2D}$3: PSNR 19.95, size 81.1 MB
• $\Sigma_{i,2D} \approx \Sigma_{k,2D}$4: PSNR 19.93, size 122.6 MB (Fang et al., 24 Feb 2026)

On Blender with 8 views, $\Sigma_{i,2D} \approx \Sigma_{k,2D}$5 attains PSNR 25.50 at 6.2 MB, and $\Sigma_{i,2D} \approx \Sigma_{k,2D}$6 achieves PSNR 25.34 at 2.6 MB (Fang et al., 24 Feb 2026). This is not merely a storage optimization; the paper presents it as an empirical demonstration that coarse-to-fine SH dropout makes truncation robust without retraining.

The analysis section provides practical tuning advice. For 3–6 views, the suggested anchor probability is $\Sigma_{i,2D} \approx \Sigma_{k,2D}$7–$\Sigma_{i,2D} \approx \Sigma_{k,2D}$8; for 9–12 views, it is reduced to $\Sigma_{i,2D} \approx \Sigma_{k,2D}$9–$\pi(\mu_i)\approx \pi(\mu_k)$0. Recommended local-cluster sizes are $\pi(\mu_i)\approx \pi(\mu_k)$1–$\pi(\mu_i)\approx \pi(\mu_k)$2 or a radius covering 1–2 local splat radii. The SH schedule should start with $\pi(\mu_i)\approx \pi(\mu_k)$3, then 1, then 2, with $\pi(\mu_i)\approx \pi(\mu_k)$4 as a default (Fang et al., 24 Feb 2026).

The limitations are also explicit. Extremely sparse views or highly occluded scenes may suffer if dropped voids intersect underspecified regions, in which case $\pi(\mu_i)\approx \pi(\mu_k)$5 or $\pi(\mu_i)\approx \pi(\mu_k)$6 should be reduced. Dynamic scenes require per-frame anchors and neighbor search. Highly specular or reflective materials may need higher $\pi(\mu_i)\approx \pi(\mu_k)$7 sooner to avoid color underfitting. The paper further notes that screen-space neighbor selection is a plausible alternative when per-view regularization is desired, but results were not reported; the main experiments use 3D $\pi(\mu_i)\approx \pi(\mu_k)$8-NN (Fang et al., 24 Feb 2026).

Within the broader sparse-view 3DGS literature, DropAnSH-GS is therefore defined by two linked ideas: defeating local redundancy through anchor-centered cluster dropout, and reducing appearance overfitting through high-degree SH suppression. The reported evidence is that these mechanisms are complementary, broadly compatible with existing 3DGS variants, computationally lightweight, and useful not only for generalization but also for model compression (Fang et al., 24 Feb 2026).