---
title: 'DropAnSH-GS: Regularization in Sparse 3DGS'
url: https://www.emergentmind.com/topics/dropansh-gs
type: topic
---

# DropAnSH-GS: Regularization in Sparse 3DGS

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 [2602.20933].

## 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 [2602.20933].

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 $c_i\approx c_k$, the lost contribution can be compensated by other splats [2602.20933].

To quantify local redundancy, the method uses spatial autocorrelation via Moran’s $I$ for a per-Gaussian attribute $x_i$:
$$
I = \frac{N}{W}\frac{\sum_i\sum_j w_{ij}(x_i-\bar{x})(x_j-\bar{x})}{\sum_i (x_i-\bar{x})^2},
$$
where $w_{ij}$ decays with 3D or screen-space distance and $W=\sum_{i,j} w_{ij}$. Empirically, $I$ 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 [2602.20933].

A second motivation concerns view-dependent color. In 3DGS, per-Gaussian color is represented with SH up to degree $L$:
$$
c_i(\omega) = \sum_{\ell=0}^{L}\sum_{m=-\ell}^{\ell} c_{i,\ell m} Y_{\ell m}(\omega).
$$
The number of color parameters is $3(L+1)^2$ 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 [2602.20933].

## 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 $A \subset \{1,\dots,N\}$ with independent Bernoulli$(p_a)$, defines a neighbor set around each anchor, and removes both the anchors and their local neighbors. The neighbor set can be either $k$-nearest neighbors in 3D,
$$
\mathcal{N}_k(i)=\{k\ \text{nearest indices to}\ \mu_i\},
$$
or a 3D radius set,
$$
\mathcal{N}_r(i)=\{j:\|\mu_j-\mu_i\|<r\}.
$$
The total dropout set is
$$
\mathcal{D}=\bigcup_{i\in A} (\{i\}\cup \mathcal{N}(i)),
$$
and the method applies
$$
o_j \leftarrow 0,\qquad \forall j\in \mathcal{D}.
$$
Equivalently, a binary mask $m_j\in\{0,1\}$ defines the effective opacity $\hat{o}_j=o_j m_j$. Because spatially adjacent Gaussians that would otherwise compensate for one another are removed together, this structured dropout creates information voids and reduces local redundancy [2602.20933].

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 $L_{\text{keep}}$ and zero all coefficients with $\ell>L_{\text{keep}}$. The other is degree-wise probabilistic masking with a Bernoulli variable $M_\ell$ whose keep probability decreases with $\ell$. The implementation used in the paper employs a simple deterministic schedule together with a per-Gaussian probability $p_{sh}$ selecting which Gaussians undergo SH truncation at a given iteration [2602.20933].

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 [2602.20933].

## 3. Rendering model, optimization, and schedules

DropAnSH-GS is built on the standard 3DGS rendering and training pipeline. A 3D Gaussian $G_i$ has mean $\mu_i\in\mathbb{R}^3$, covariance $\Sigma_i$, and opacity $o_i\in[0,1]$. Projecting to the screen yields $\Sigma_{i,2D}$ 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).
$$
With depth sorting,
$$
T_i(p)=\prod_{j<i}(1-\alpha_j(p)),\qquad
C(p)=\sum_{i=1}^N T_i(p)\alpha_i(p)c_i(\omega_p).
$$
The SH appearance model remains
$$
c_i(\omega)=\sum_{\ell=0}^{L}\sum_{m=-\ell}^{\ell} c_{i,\ell m}Y_{\ell m}(\omega).
$$
DropAnSH-GS does not alter this renderer fundamentally; it inserts ephemeral opacity and SH masks before compositing [2602.20933].

The loss follows standard 3DGS practice:
$$
\mathcal{L}=\|\hat{S}-I_{gt}\|_1 + \lambda \bigl(1-\mathrm{SSIM}(\hat{S},I_{gt})\bigr),
$$
with the paper keeping the original per-dataset setup from 3DGS and not introducing extra regularizers [2602.20933].

The reported training schedule is specific. The anchor probability $p_a$ is linearly ramped from $0$ to $0.02$ over 10k iterations. The neighbor count is $k=10$ using 3D $k$-NN. The SH-drop probability is $p_{sh}=0.2$. The deterministic SH schedule is coarse-to-fine:
- $L_{\text{keep}}=0$ at 2k iterations,
- $L_{\text{keep}}=1$ at 4k iterations,
- $L_{\text{keep}}=2$ at 6k iterations,
- training continues to 10k iterations [2602.20933].

Sensitivity analysis on LLFF with 3 views identifies effective ranges: $p_a \approx 0.01$–$0.02$, $k \approx 5$–$15$, and $p_{sh} \approx 0.2$–$0.3$. The stated interpretation is that values that are too small weaken regularization, while overly aggressive values harm geometry and convergence [2602.20933].

The per-iteration loop is straightforward. A mini-batch of rays or pixels is sampled; anchors are drawn via Bernoulli$(p_a)$; neighbors are queried; the opacity mask is applied; SH truncation is applied to selected Gaussians; a forward render produces $\hat{S}_t$; the loss is backpropagated; and all masks are restored for the next iteration. The parameters themselves persist, while masking is temporary [2602.20933].

## 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 $m_i$, a per-iteration SH mask zeroing high-degree coefficients, and a fast neighbor search backend over Gaussian means $\mu_i$ [2602.20933].

The implementation guidance is correspondingly minimal. Neighbor search can use a GPU cell grid or hash-based index, or CUDA $k$-NN. The method maintains mask buffers on GPU, computes $\hat{o}_i=o_i m_i$ before the forward pass, and applies degree masks directly to $c_{i,\ell m}$. The same masks are reused across all rays in a batch, and the spatial index may be reused or updated every $M$ iterations. The implementation is described as using PyTorch, with efficiency references to CUDA $k$-NN [2602.20933].

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 [2602.20933].

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 [2602.20933].

## 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 [2602.20933].

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** [2602.20933].

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** [2602.20933].

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** [2602.20933].

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%)** [2602.20933]

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 [2602.20933].

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** [2602.20933].

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 [2602.20933].

## 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 $L' \leq L$ by setting
$$
c_{i,\ell m}\leftarrow 0,\qquad \forall \ell > L'.
$$
Because training concentrates appearance information into low-degree SH, the model is designed to remain robust under such truncation [2602.20933].

The parameter-count reduction is explicit. Per Gaussian, color parameters decrease from
$$
3(L+1)^2
$$
to
$$
3(L'+1)^2.
$$
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:
- **$L'=0$**: **PSNR 19.71, size 33.8 MB**
- **$L'=1$**: **PSNR 19.86, size 51.8 MB**
- **$L'=2$**: **PSNR 19.95, size 81.1 MB**
- **$L'=3$**: **PSNR 19.93, size 122.6 MB** [2602.20933]

On Blender with 8 views, **$L'=3$ attains PSNR 25.50 at 6.2 MB**, and **$L'=1$ achieves PSNR 25.34 at 2.6 MB** [2602.20933]. 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 **$p_a \approx 0.01$–$0.02$**; for **9–12 views**, it is reduced to **$\approx 0.005$–$0.01$**. Recommended local-cluster sizes are **$k \approx 5$–$15$** or a radius covering **1–2 local splat radii**. The SH schedule should start with **$L_{\text{keep}}=0$**, then **1**, then **2**, with **$p_{sh}\approx 0.2$** as a default [2602.20933].

The limitations are also explicit. Extremely sparse views or highly occluded scenes may suffer if dropped voids intersect underspecified regions, in which case $p_a$ or $k$ should be reduced. Dynamic scenes require per-frame anchors and neighbor search. Highly specular or reflective materials may need higher $L_{\text{keep}}$ 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 $k$-NN [2602.20933].

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 [2602.20933].

Source: https://www.emergentmind.com/topics/dropansh-gs