Pb4U-GNet: Propagation-before-Update GNN

• The paper introduces Pb4U-GNet, which decouples message propagation and node updates to allow customizable receptive fields and improved model stability.
• It achieves significant efficiency gains, with training throughput improvements up to 156× on large-scale graphs compared to traditional GNNs.
• The approach demonstrates robust performance in applications like garment simulation by incorporating geometry-aware scaling and adaptive propagation depth.

Propagation-before-Update Graph Network (Pb4U-GNet) refers to a class of graph neural network (GNN) architectures in which message propagation (feature aggregation) and node feature updates are explicitly decoupled, with all propagation steps performed before any nontrivial update operation. This separation enables adaptive neighborhood coverage, greater model stability across graph resolutions or scales, and efficient system-level optimizations. The paradigm has been instantiated for physics-based garment simulation, scalable large-graph learning, and prioritized propagation in GNNs, each leveraging the propagation-before-update split for application-specific robustness and efficiency (Liu et al., 21 Jan 2026, Cheng et al., 2023, Yue et al., 17 Apr 2025).

1. Core Paradigm: Decoupling Propagation and Update

Classical message-passing GNNs typically perform, within each layer, a message aggregation followed immediately by a feature update. This interleaved approach fixes both the receptive field and the update depth, and as a consequence, ties representational power and stability to the network depth and the underlying graph’s properties.

In a Pb4U-GNet, propagation is performed as a distinct stage: multiple rounds of message aggregation are executed, each extending information flow further in the graph, but without altering the initial latent features. After the desired number of propagation steps—typically determined adaptively based on task or graph structure—a learnable update function fuses the accumulated context with the original node features. This separation enables precise control of receptive field independent of update dynamics, and allows other modules (such as geometry-aware scaling or personalized propagation depth controllers) to be cleanly inserted (Liu et al., 21 Jan 2026, Cheng et al., 2023).

2. Resolution-Adaptivity and Dynamic Propagation Depth

Pb4U-GNet architectures support adaptive control of the propagation horizon to maintain a consistent physical or semantic coverage across graphs of varying resolution, density, or node priority. In resolution-adaptive garment simulation (Liu et al., 21 Jan 2026), the number of propagation hops $K$ is dynamically set so that the product $K \cdot \bar{L}$ (mean edge length) stays constant: $K = \left\lfloor \frac{D}{\bar{L}} \right\rfloor$ where $$D = K_{\mathrm{base}} \cdot \bar{L}_{\mathrm{base}}$$ is the desired physical distance, and $\bar{L}$ is the mean edge length of the current mesh. This ensures that information aggregates over a fixed spatial radius, preventing over- or under-smoothing as mesh density varies.

In prioritized propagation (Cheng et al., 2023), individualized per-node propagation depths are learned by a neural controller, so nodes dynamically determine how many hops of message passing they need before updating, based on local priority features. This mechanism handles heterophily, node influence, and content-specific dynamics without incurring unnecessary propagation on low-priority regions.

3. Geometry- and Priority-Aware Update Strategies

Pb4U-GNets incorporate mechanisms to preserve the correct physical or semantic scale of learned updates after message propagation:

• In geometry-aware garment simulation (Liu et al., 21 Jan 2026), vertex-wise updates are scaled by a factor $s_i$ derived as the mean incident edge length at vertex $i$:

$$s_i = \frac{1}{|\mathcal N(i)|}\sum_{j\in\mathcal N(i)} l_{ij}$$

This enforces that, under uniform deformation, vertex-wise displacements scale linearly with element size—crucial for stability when generalizing across mesh densities.

• In prioritized propagation (Cheng et al., 2023), a weight controller assigns each node $i$ a scalar weight $w_i$ that re-weights the supervised loss for model parameter updates, based on a learned function of node degree, centrality, heterophily, and per-node propagation depth. The overall training criterion becomes:

$$L_g(\theta, w) = \frac{1}{m} \sum_{i\in\text{train}} [w_i \cdot C(y_i, \hat{y}_i)] - \lambda_1 \frac{1}{m}\sum w_i^2$$

This design promotes both expressive propagation and robustness to node priority.

4. Algorithmic Workflow and Key Equations

A canonical Pb4U-GNet pipeline involves:

1. Propagation-only stage: perform $K$ rounds of message-passing, accumulating at each node a hidden state $\mathbf{h}_i^{(K)}$, without updating the original latent embedding $\mathbf{v}_i$.
2. Update stage: apply a learnable function $f_u$ that fuses $\mathbf{h}_i^{(K)}$ with $\mathbf{v}_i$:

$$\mathbf{v}_i' = f_u(\mathbf{v}_i,\ \mathbf{h}_i^{(K)})$$

1. Further refinement: process $\{\mathbf{v}_i'\}$ by a standard GNN stack (e.g., MeshGraphNet blocks), producing refined embeddings $\{\mathbf{v}_i''\}$.
2. Decoding and scaling: generate predictions (e.g., accelerations $\tilde{a}_i$) from $\mathbf{v}_i''$, scale as appropriate (e.g., $a_i = s_i \cdot \tilde{a}_i$).
3. Integration: for dynamical systems (e.g., garment simulation), update physical states using the predicted quantities.

The message-passing pass takes the general form: $$\begin{aligned} m_{ij}^{(k)} &= f_m(\mathbf{h}_i^{(k-1)}, \mathbf{h}_j^{(k-1)}, \mathbf{e}_{ij}) \ \widetilde{\mathbf{h}}_i^{(k)} &= \mathrm{LayerNorm}\left(\sum_{j\in\mathcal N(i)} m_{ij}^{(k)}\right) \ \mathbf{h}_i^{(k)} &= \gamma \mathbf{h}_i^{(k-1)} + \widetilde{\mathbf{h}}_i^{(k)} \ \end{aligned}$$ where $f_m$ is a learnable message function and $\gamma\in(0,1)$ is a decay factor (Liu et al., 21 Jan 2026).

5. System-Level Efficiency and Scalability

Pb4U-GNet designs fundamentally alter GNN training and inference dynamics by moving sparse propagation out of the main training loop. In large-scale graph learning (Yue et al., 17 Apr 2025), all $R$-hop feature aggregation is performed as a preprocessing step: $$H_k^{(r)} = B_k \cdot H_k^{(r-1)},\quad r=1,\dots,R$$ where typically $B_k$ is a sparse adjacency operator. These pre-propagated features are stacked and serve as dense input to the downstream model, removing neighbor explosion and enabling dense-only computation kernels.

Key empirical findings include:

• Training throughput improved by $9$–$42\times$ over sampling-based GNNs on benchmarks with up to 100M nodes, with negligible or no accuracy drop (Yue et al., 17 Apr 2025).
• Input expansion becomes linear in $R$ (the number of pre-propagation hops), as opposed to the exponential scaling in standard GNNs with many layers.
• System bottlenecks such as data loading and memory usage (due to expanded features) are mitigated by double-buffer GPU prefetching, chunk reshuffling, and direct GPU storage access. For extreme-scale graphs exceeding host memory, chunk-wise transfer and GPU Direct Storage allow effective scaling with modest throughput drop.

A summary table of comparative throughput is as follows:

Dataset	MP-GNN Throughput (eps)	Pb4U-GNet Throughput (eps)	Speedup
ogbn-products (2.4M)	1.5	14.2–14.6	9.5–9.7×
ogbn-papers100M (111M)	0.12	1.56–4.36	13–36×
IGB-medium (10M/39GB)	0.06	5.43–9.35	90–156×
IGB-large (100M/400GB)	0.65	8.58–10.52	13–16×

*eps = epochs/second; all metrics from (Yue et al., 17 Apr 2025).

6. Empirical Performance and Application Studies

Garment simulation benchmarks (Liu et al., 21 Jan 2026) show that the resolution-adaptive Pb4U-GNet, trained only at the lowest resolution, generalizes strongly across mesh resolutions. For example, stretch-loss on 38K-triangle evaluation increases sharply for fixed-depth GNN baselines ($> 10^5$), but remains $O(10^{-1})$ for Pb4U-GNet. Ablation demonstrates that removing dynamic propagation control or geometry-aware scaling leads to catastrophic failure at higher mesh resolutions.

In prioritized propagation (Cheng et al., 2023), Pb4U-based models outperform fixed-step GNNs and prior learn-to-propagate frameworks across eight homophilous and heterophilous benchmarks, demonstrating both improved accuracy and robustness against over-smoothing at large depth.

7. Limitations and Further Directions

Despite the theoretical and empirical advantages, Pb4U-GNet approaches have limitations:

• Propagation cost grows as $O(K|\mathcal E|)$ for high-resolution or dense graphs if message propagation is not amortized or parallelized.
• The linear input expansion with $K$ (or $R$) can exceed device memory limits for very large graphs, requiring system-level strategies such as chunking or out-of-core data handling.
• Certain physical applications (e.g., highly non-uniform meshes) may require enhanced local geometric normalization.
• Most implementations utilize a global decay or static controller; learnable or per-node gating for long-range effects remains an open research area.

Research is ongoing into further improving adaptivity, memory efficiency, and generalization in both graph learning and simulation contexts (Liu et al., 21 Jan 2026, Cheng et al., 2023, Yue et al., 17 Apr 2025).