Reverse Per-Gaussian Parallel Optimization

• Reverse per-Gaussian parallel optimization is a high-efficiency framework that updates Gaussian primitives in parallel, reducing atomic update contention.
• It leverages CUDA warps and tile-based data locality to achieve significant speedups, demonstrated by up to a 3× improvement in large-scale 3D reconstruction tasks.
• The method connects convex optimization with reverse water-filling strategies, offering broad applications in geometric regularization and high-throughput inference.

Reverse per-Gaussian parallel optimization is a high-efficiency computational framework where optimization updates are reorganized to operate over sets of Gaussian primitives in parallel, rather than over pixels or data points. This restructuring significantly improves performance and scalability in domains where Gaussian models serve as fundamental units, such as large-scale 3D reconstruction. The “reverse” aspect refers to the backward pass accumulation order, processing gradients per-Gaussian in warps rather than per-pixel, which prioritizes Gaussian-centric accumulations and minimizes atomic update contention. Parallelization exploits CUDA warps and tile-based data locality, enabling rapid convergence under stringent computational budgets. The concept is closely related to convex optimization strategies over Gaussian components in tasks ranging from joint source-channel coding to geometric regularization, and reflects a broader trend toward atomic, blockwise updates in large-scale computation.

1. Mathematical Formulation and Optimization Objective

A scene is modeled as a set of $N$ 3D Gaussians (splats), each parameterized by position $\mu_i \in \mathbb{R}^3$, covariance $\Sigma_i$ (or 2D projection $[a_i, b_i, c_i]$), color $c_i \in \mathbb{R}^3$, and opacity $o_i \in [0,1]$ (Zhang et al., 27 Jan 2026). In the Neural-Gaussian variant, attributes are generated via a small MLP $f_\theta$ from anchor features $f_j$, but optimization proceeds identically.

Given a set of $M$ training views, the optimization objective is

$$L(\Theta, \Delta) = \sum_{j=1}^M \left[ L_{\text{photo}}^j + \alpha(t) L_{\text{depth}}^j \right] + \lambda_{\text{pose}} \|\Delta R\|^2 + \|\Delta t\|^2,$$

where $\Theta$ collects all Gaussian (or anchor+MLP) parameters, and $\Delta$ denotes pose corrections. Photometric loss combines $L_1$ and SSIM terms, depth uses $L_1$ in disparity, and $\alpha(t)$ anneals depth regularization. Gradients $\partial L/\partial \Theta$ and $\partial L/\partial \Delta$ are sought for parameter updates.

2. Reverse Per-Gaussian Backward Pass

Traditional per-pixel backward optimization aggregates gradients by iterating over each pixel’s contributing Gaussians, causing high atomic update contention. In contrast, reverse per-Gaussian parallel optimization accumulates gradients per-Gaussian and per-warp. Each CUDA warp (block of 32 threads) iterates over K splats, cooperatively scans associated pixels in a tile, and aggregates gradients for each Gaussian into local registers. Only a single atomic add is performed per splat at the end, eliminating the contention from dense pixel-splat intersections (Zhang et al., 27 Jan 2026).

Forward pass caching records, per pixel and splat, the transmittance $T_k(x,y)$, blended color $C_k(x,y)$, and blended centroid depth $D_k(x,y)$ in warp-local caches, enabling rapid and memory-efficient reuse in the backward pass.

3. Parallelization, Data Structures, and Algorithmic Implementation

The forward pass assigns each Gaussian to a set of image tiles using compact “SnugBox” bounds. Tiles are processed in blocks to maintain load balance and prune irrelevant regions. The image is divided into $16 \times 16$ pixel blocks, with Gaussians grouped in chunks of $K=32$ per block. Each warp is responsible for one such group in one tile (Zhang et al., 27 Jan 2026).

Within each tile:

• Warps scan all pixels, computing analytic derivatives $\partial I/\partial \theta_i$, $\partial d/\partial \theta_i$ for each Gaussian based on forward-pass accumulators.
• Gradients are accumulated for each splat into local registers.
• After all pixels have been processed, a single atomic add updates the global parameter gradients for each Gaussian.
• Pose parameters $\Delta$ are optimized by differentiating ray directions and depths, with gradients accumulated during the same backward pass.

Pseudocode for each backward iteration succinctly expresses the per-warp/per-Gaussian update logic, minimizing synchronization costs.

4. Connections: Convex Optimization over Parallel Gaussians

Reverse per-Gaussian parallel optimization generalizes the convex optimization framework established for parallel Gaussian sources (0901.2396). For a source $S = (S_1,\ldots,S_N)$ with $S_i \sim \mathcal{N}(0,\sigma_i^2)$, the classical rate-distortion function is

$$R_i(D_i) = \frac{1}{2} \log_2\left(\frac{\sigma_i^2}{D_i}\right) \quad \text{for } 0 < D_i < \sigma_i^2.$$

Minimizing total rate subject to an average distortion $\frac{1}{N}\sum D_i \le D_\text{target}$ yields a reverse water-filling solution,

$$D_i = \min\{\sigma_i^2, \gamma\}, \quad R_i(D_i) = \begin{cases} \frac{1}{2}\log_2(\sigma_i^2/\gamma), & \sigma_i^2 > \gamma; \ 0, & \sigma_i^2 \le \gamma. \end{cases}$$

Reverse per-Gaussian update strategies can thus be viewed as computational analogues of reverse water-filling, optimizing over Gaussian primitives with global constraints in parallel fashion.

5. Practical Implementation in 3D Gaussian Splatting

Reverse per-Gaussian parallel optimization has been practically deployed in high-throughput 3D reconstruction pipelines (Zhang et al., 27 Jan 2026). Essential implementation features include:

• Forward splatting with tile-pruned SnugBox bounds and load-balanced blocks;
• Warp-mapped backward passes for simultaneous per-Gaussian gradient accumulation;
• On-the-fly pose correction via $\Delta R$, $\Delta t$ gradients in the backward pass;
• Integration with anchor-based Neural-Gaussians for parameter-efficient representation;
• Depth regularization annealed during early training iterations.

Experimental evidence demonstrates that replacing pixel-based backward passes with per-Gaussian parallel backprop produces a 3× speedup (600 s→180 s for 30k iterations on the TNT dataset). Further gains are obtained by compact tiling and balanced writing, reducing the total time to ≈176 s. The full pipeline achieves photorealistic quality with 25.48 dB PSNR in 60 s under noisy pose conditions and 28.72 dB in 56.2 s with accurate poses.

6. Relevance to Isoperimetric and Regularization Inequalities

The reverse per-Gaussian paradigm retains geometric and probabilistic influences from isoperimetric inequalities for parallel sets in $\mathbb{R}^d$. Upper bounds on surface area for $r$-parallel sets (Minkowski thickening) are given by $e^{\Theta(d)} V/r$ for Euclidean measures, and by $\max(e^{\Theta(d)}, e^{\Theta(d)}/r)$ for Gaussian measures (Jog, 2020). These inequalities constrain the complexity and generalization properties of Gaussian-based models, paralleling the regularization effects produced by parallel optimization over Gaussians in high-dimensional spaces. The reverse entropy power inequality provides additional information-theoretic grounding for Gaussian smoothing as a geometric regularizer.

7. Applications and Implications

Reverse per-Gaussian parallel optimization directly enables large-scale, time-constrained learning and inference for settings with Gaussian primitives:

• 3D Reconstruction: Enables high-fidelity, minute-scale geometry and appearance estimation with Gaussian splats (Zhang et al., 27 Jan 2026).
• Source-Channel Coding: Allows convex allocation of rate and distortion across parallel Gaussian channels by reverse water-filling (0901.2396).
• Machine Learning Robustness: Facilitates sample complexity and risk estimation in adversarial contexts via bounds that scale with surface area and packing of Gaussian-thickened sets (Jog, 2020).

This suggests a broad applicability where the efficiency and regularization properties inherent in parallel per-Gaussian updates provide computational leverage across geometric, statistical, and signal processing tasks.

---

Core Optimization Instance	Update Unit	Parallelism Granularity
3D Gaussian Splatting (Zhang et al., 27 Jan 2026)	Gaussian Splats	CUDA Warp, Tile Block
Source-Channel Coding (0901.2396)	Gaussian Sources	Global, Layer
Isoperimetric Set Regularization (Jog, 2020)	Parallel Sets	Packing/Cluster

The consistent theme is optimization performed directly on sets of Gaussian primitives, with reverse accumulation and parallel execution dramatically improving efficiency.