Bidirectional Graph Decoupling Optimization

• BGDO is a framework that decouples and bidirectionally optimizes deep layered architectures such as GNNs and simulation pipelines for efficient, modular training.
• It introduces reversible, fully‐separable module boundaries and lightweight backward passes to propagate corrective signals and reduce error accumulation.
• BGDO achieves robust convergence and improved performance on tasks like node clustering in GNNs and material parameter refinement in 3D Gaussian Splatting simulations.

Bidirectional Graph Decoupling Optimization (BGDO) is a general framework for decoupling and bidirectionally optimizing deep, layered architectures—principally, graph neural networks (GNNs) and, in specific adaptations, differentiable simulation pipelines. BGDO achieves significant efficiency gains and stability by separating large, monolithic computation graphs into modular subcomponents, each optimized via both forward and backward objectives. Core to BGDO is the design of reversible, fully-separable module boundaries and the introduction of lightweight backward passes that propagate information from deeper to shallower layers or simulation stages. BGDO has been demonstrated both as a GNN training paradigm (as SGNN) (Zhang et al., 2023) and as an adaptive parameter refinement layer in 3D Gaussian Splatting-based physical simulation (Ma et al., 2 Feb 2026).

1. Architectural Principle and Decoupling Strategy

BGDO applies to multilayer computational architectures by partitioning the system into $L$ distinct modules $\mathcal{M}_1, \ldots, \mathcal{M}_L$. For GNNs, this decoupling is formalized through two separable operations per module: a graph operation $f_0^{(t)}$ and a neural operation $f_1^{(t)}$. The forward path propagates features through these modules in classical topological order, while a specially designed backward path allows information from deeper modules to regularize or inform shallower ones.

For a GNN with adjacency $A$ and features $X$, a standard composite network

$$H = f_L(A, f_{L-1}(\ldots f_1(A, X; W_1)\ldots; W_{L-1}); W_L)$$

is decoupled into modules each of form

$$H_t = f^{(t)}(A, X_t; W_t) = f_1^{(t)}(f_0^{(t)}(A, X_t), W_t)$$

where $X_{t+1} \leftarrow H_t$ is the forward linkage.

Crucially, the separability of $f_0^{(t)}$ ensures that—in the backward pass—module outputs can be transformed by auxiliary linear maps $U_t$ so as to construct “expected” features for upstream layers. This underlies the bidirectional coupling.

In physics-based simulation (e.g., FastPhysGS), BGDO decouples the main forward simulation (MPM steps parameterized by predicted material parameters) from a backward pseudo-simulation that computes adaptive corrections to key parameters (e.g., Young’s modulus $E$), driven by recorded snapshots and dual physical signals (Ma et al., 2 Feb 2026).

2. Bidirectional Training Objectives

Each module in BGDO is optimized via an augmented objective that combines local forward and backward terms:

$$\mathcal{L}^{(t)}(W_t, U_t) = \mathcal{L}_{FT}^{(t)}(W_t) + \eta\,\mathcal{L}_{BT}^{(t)}(W_t, U_t)$$

with $\eta > 0$. The forward loss $\mathcal{L}_{FT}^{(t)}$ depends on the application—for GNNs it may be a reconstruction, classification, or autoencoder loss; for simulation it can involve stress or deformation targets. The backward loss $\mathcal{L}_{BT}^{(t)}$ penalizes mismatch between the module’s output and the features needed by the subsequent module (or physical state).

In GNNs, backward loss is computed using invertible transforms and auxiliary parameters $U_t$, enabling deeper module outputs $Z_{t+1}$ to inform shallower modules. In 3DGS simulation, the backward step uses gradients of stress norms with respect to log-parameters, and pseudo-simulation steps to estimate local physical sensitivity without expensive time integration.

The global optimization aggregates per-module losses:

$$\min_{\{W_t, U_t\}} \sum_{t=1}^L [\mathcal{L}_{FT}^{(t)}(W_t) + \eta\,\mathcal{L}_{BT}^{(t)}(W_t, U_t)]$$

establishing a two-pass, bidirectional SGD regime.

3. BGDO Algorithmic Workflow

The standard BGDO loop for GNNs is as follows (Zhang et al., 2023):

• Initialization: Randomly initialize projection weights $W_t$ and set all $U_t$ to identity, for $t=1,\ldots,L$.
• Forward Training (FT) Pass: Sequentially process each module:
  • Apply $f_0^{(t)}$ to input features.
  • Compute module loss (incl. BT after the first epoch).
  • Update $W_t$ via SGD.
  • Propagate output as input to the next module.
• Backward Training (BT) Pass: Iterate from deepest to shallowest module:
  • Compute expected input from downstream module via separable inverse operation and $U_{t+1}$.
  • Update $(W_t, U_t)$ jointly with both FT and BT losses.

For simulation (FastPhysGS), the forward MPM executes with initial material parameters and only stores a handful of frames. The backward pass replays pseudo-simulation steps, computes stress gradient and deformation signals for each snapshot, blends these using an adaptive weight $\alpha$, and updates log-parameters in a single or double iteration loop (Ma et al., 2 Feb 2026).

4. Theoretical Properties and Guarantees

In unsupervised linear settings, BGDO provably prevents error accumulation across modules. Let $H_t = PX_tW_t$ with $P = \phi(A)$ and loss $\|\; P - H_tH_t^T\|_F$. If the prior module has error at most $\varepsilon$, there always exists $W_t$ such that the following module’s error does not exceed $\varepsilon$; that is, error is non-increasing. When certain commutativity assumptions fail, error increases only by a bounded constant proportional to the square of neglected singular values, not multiplicatively with depth:

$$\mathcal{L}_{FT}^{(L)} \leq \mathcal{L}_{FT}^{(1)} + \sum_{t=1}^{L-1} O(\sigma_*^2(H_t))$$

thus eliminating exponential error blow-up and ensuring depth-robustness (Zhang et al., 2023).

For physically-motivated parameter refinement, BGDO guarantees that even with poor initial guesses (orders of magnitude too high/low), the adaptive backward step converges to a physically realistic value within one or two iterations, stabilizing simulation outcomes across material regimes (Ma et al., 2 Feb 2026).

5. Application Case Studies

Graph Neural Network Training (SGNN)

On node clustering and semi-supervised classification benchmarks (Cora, Citeseer, PubMed, Reddit), BGDO:

• Matches or surpasses sampling-based scalable GNNs (GraphSAGE, FastGCN, Cluster-GCN, SGC).
• Achieves similar or better clustering accuracy (e.g., 0.74 ACC with BT vs. 0.69 ACC without BT on Cora) and has no performance degradation with greater module depth.
• Offers a per-iteration complexity of $O(m d_{t-1}d_t)$ (for mini-batch size $m$) with only a single graph-based preprocessing per epoch, resulting in lower training times than most neighbor-sampling methods (Zhang et al., 2023).

Physics-based Dynamic 3D Gaussian Splatting (FastPhysGS)

Within the FastPhysGS pipeline, BGDO:

• Rapidly refines VLM-predicted Young’s modulus $E$ and produces physically plausible object deformation.
• Requires only three stored simulation frames and <1 s for backward parameter refinement on commodity hardware.
• Gains substantial improvements over ablations: removal of BGDO drops CLIP Score from 0.292 to 0.217, lowers Aesthetic Score from 4.71 to 3.34, and reduces semantic/physical adherence scores, despite identical simulation forward passes (Ma et al., 2 Feb 2026).

6. Experimental Results and Practical Considerations

Empirical evaluation highlights the following findings:

• Efficiency: BGDO minimizes memory overhead (constant w.r.t. time or depth) and achieves end-to-end runtimes of ~1 minute for 3DGS simulation, requiring only 7 GB memory for full dynamics and backward passes.
• Stability: BGDO provides robust convergence even from extreme misinitalizations (e.g., Young’s modulus off by many orders of magnitude). Physical plausibility is maintained for a variety of material models (elastomers, sand, water, etc.) and energetic regimes.
• Convergence: In both GNN and simulation domains, one or two iterations of BGDO's backward phase suffice for ultimate performance.
• Implementation: For simulation, BGDO uses PyTorch and Taichi, and for GNNs, it deploys SGD-style updates without specialized optimizer sophistication.

A summary of computational and evaluation statistics is presented below:

Metric	Value	Context
BGDO backward time	< 1 sec	FastPhysGS/Simulation (Ma et al., 2 Feb 2026)
Total memory usage	7 GB	FastPhysGS/Simulation
Training complexity	$O(m d_{t-1} d_t)$	GNN/SGNN (Zhang et al., 2023)
Cluster ACC (BGDO FT)	0.69	Cora dataset, GNN
Cluster ACC (BGDO BT)	0.74	Cora dataset, GNN
CLIP Score (w/ BGDO)	0.292	FastPhysGS ablation
CLIP Score (w/o BGDO)	0.217	FastPhysGS ablation

7. Extensions and Cross-domain Relevance

BGDO’s decoupling and bidirectional principles demonstrate broad applicability: any layered computation amenable to modularization and invertibility can potentially benefit from such optimization, ranging from deep GNNs to differentiable simulation frameworks. Within simulation, BGDO achieves rapid adaptation to perceptual prediction failures, and in GNNs, it provides layerwise scalability while evading the pitfalls of vanishing gradients or error propagation. A plausible implication is that further extensions of BGDO could leverage richer backward signals (e.g., higher-order derivatives, domain-specific constraints) in both learning and inverse problems across scientific computing and machine learning.