Graph-Based ML Emulators

• Graph-based machine learning emulators are surrogates that convert simulation domains into structured graphs and use GNNs to capture essential dynamical properties, reducing computational costs.
• They implement an encode–process–decode architecture with message passing and prototype mechanisms, ensuring physical consistency and efficient latent variable integration.
• Empirical results demonstrate significant speed-ups (up to 500× faster) and improved accuracy in metrics like IoU across diverse domains such as climate modeling and space physics.

Graph-based machine learning emulators are a class of surrogates that leverage structured graph representations and graph neural network (GNN) architectures to emulate the input–output or spatiotemporal behavior of high-fidelity physical simulations. These emulators are designed to drastically reduce computational costs and wall-clock times compared to direct numerical solvers, while faithfully capturing the essential dynamical or structural properties of the target system across a range of scientific and engineering domains.

1. Graph Formulation of Physical and Scientific Problems

The core principle underlying graph-based emulators is the translation of a simulation domain into a graph or a collection of graphs whose nodes and edges reflect either physical discretization, scientific logic, or both. For spatially distributed systems governed by PDEs—such as climate modeling or plasma physics—regular grids or adaptive meshes are naturally mapped into nodes representing spatial cells, with edges denoting adjacency or physical coupling. Node feature vectors routinely encode local physical variables, geography, or coordinates, while edge features may express spatial deltas or connectivity patterns (Keshtmand et al., 24 Apr 2025, Holmberg et al., 18 Jan 2026).

In multi-fidelity and uncertainty quantification contexts, the dependence structure between models of varying resolution is encoded as a directed acyclic graph (DAG), with each node representing a distinct simulator or stage and edges denoting dependency, as in the Graphical Multi-fidelity Gaussian Process (GMGP) formalism (Ji et al., 2021).

Hierarchical and multiscale constructions enable the efficient representation of long-range interactions in $N$-body or fluid systems by recursive spatial subdivision (quadtree/octree), resulting in sparse graphs with $O(N)$ nodes and $O(N)$ edges (Martinkus et al., 2020).

2. Neural Architectures and Message-Passing Schemes

Graph-based emulators primarily employ GNNs that operate under an encode–process–decode paradigm. The architecture consists of:

• Encoder: Projects raw input features (physical state, coordinates, boundary masks) into a latent node embedding, typically via small multilayer perceptrons (MLPs) with activation functions such as Swish (SiLU) and normalization layers (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).
• Processor: Executes $L$ rounds of message passing, where at each layer, messages $m_{ij}^{(\ell)}$ are computed for each edge $(i,j)$ by an MLP $\phi_m$ and aggregated at every node. Node states are updated by another MLP $\phi_u$ according to

$$h_i^{(\ell+1)} = \phi_u(h_i^{(\ell)}, \sum_{j \in \mathcal{N}(i)} \phi_m(h_i^{(\ell)}, h_j^{(\ell)}, e_{ij}))$$

with domain-specific variations, including residual forms and hierarchical upward/downward passes in multilevel graphs (Keshtmand et al., 24 Apr 2025, Martinkus et al., 2020).

• Decoder: Maps final node embeddings back to desired physical outputs (e.g., concentration fields, plasma moments) and, when necessary, interpolates results onto the original simulation grid using barycentric or stencil-based interpolation.

Specialized architectures extend this pattern. In the case of the GMGP, inference and update recursions are carried out depth-wise along the DAG, rendering prediction computationally feasible even for complex multi-fidelity ensembles (Ji et al., 2021). Polaritonic ML systems physically instantiate the graph in a nonlinear hardware substrate, where message passing is replaced by physical coupling mediated by the pattern of optical pumping and condensate interactions (Wang et al., 14 Jul 2025).

3. Enhanced Emulation via Prototypes, Latent Variables, and Physics Constraints

Graph-based emulators can be augmented in both inputs and learning objectives to improve performance and fidelity. The prototype mechanism introduces a low-cost or empirical approximation of the emulator’s output as an additional channel in the node features. Selection of prototypes may be random, expert-driven, or algorithmic (e.g., PCA-k-means clustering in prototype space), and these are assigned to each prediction sample via projection and nearest-neighbor search. This approach supplies a strong prior guiding the GNN toward residual correction and reduces mode collapse to generic solutions (Keshtmand et al., 24 Apr 2025).

Uncertainty quantification is realized through hierarchical latent variable constructs. In Graph-EFM, mesh-level latent variables $Z^t$ are sampled from a prior $p(Z^t\mid X^{t-2:t-1})$, and predictions are generated by conditioning the GNN decoder on both physical inputs and these stochastic latents, trained with variational ELBO objectives and fine-tuned by the Continuous Ranked Probability Score (CRPS) for calibrated ensemble outputs (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).

Physical consistency can be enforced by explicit penalty terms in the loss. For instance, divergence-freeness of the magnetic field $\nabla \cdot \mathbf{B} = 0$ is promoted by the regularizer

$$L_{\mathrm{Div}} = \frac{1}{T N} \sum_{t=1}^T \sum_{n=1}^N \left(\partial_x \hat B^t_x + \partial_z \hat B^t_z\right)_n^2,$$

where derivatives are discretized appropriately (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).

4. Scalability, Inference Speed, and Numerical Performance

The principal motivation for graph-based ML emulators is the orders-of-magnitude reduction in inference time relative to direct simulation. Multiple recent works report emulation speeds $\sim$500$\times$ faster than their parent solvers (e.g., Vlasiator) for space plasma forecasting, with deterministic models averaging $\sim$0.5 s per prediction step on a single GPU versus several minutes on 100+ CPU cores (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).

Hierarchical architectures enable linear scaling in $N$ for $N$-body or high-resolution mesh systems, with message passing cost $O(N)$ and preprocessing $O(N \log N)$ (Martinkus et al., 2020). This scaling is preserved as the number of agents or mesh cells increases, and models trained on moderate $N$ generalize to larger $N$ due to bounded node degrees and uniform interaction patterns.

Accuracy is quantitated using metrics such as RMSE, CRPS, and Intersection-over-Union (IoU). Empirical studies consistently show that GNNs equipped with physically motivated priors (e.g., prototypes) or hierarchical message passing outperform baseline models both in reconstructing fine-scale details and in ensemble statistics. Diminishing returns in performance are observed as the number of prototypes increases beyond a moderate threshold (e.g., $n\approx 20{-}30$ in climate footprint emulation) (Keshtmand et al., 24 Apr 2025).

5. Specialized Domains: Physical Systems, Multi-Fidelity, and Hybrid Platforms

Graph-based emulators have demonstrated efficacy across a diverse set of scientific problems:

• Climate and atmospheric dispersion: Emulating high-dimensional concentration footprints from meteorological and geographic inputs, with prototype-enhanced GNNs delivering sharper, less over-smoothed outputs and $\sim$8% higher mean IoU (Keshtmand et al., 24 Apr 2025).
• Space physics (hybrid-Vlasov): Autoregressive deterministic and probabilistic graphs capture magnetospheric response under varying solar-wind forcing, with calibrated uncertainty quantification and real-time capability (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).
• Multi-fidelity UQ: GMGPs enable emulation across simulator hierarchies by encoding dependency DAGs and propagate uncertainty posteriors recursively with controlled numerical complexity (Ji et al., 2021).
• Long-range interacting particle systems: Hierarchical graph constructs reduce computational bottlenecks in $N$-body emulation, preserving the dominant physics while lowering the scaling to $O(N)$ (Martinkus et al., 2020).
• Photonic/hardware-accelerated ML: Polaritonic lattices physically embed graph topologies in nonlinear photonic condensates; CF, triangle detection, and Betti number inference tasks are mapped to quantized vortex patterns in light, accelerating feature extraction for downstream neural architectures (Wang et al., 14 Jul 2025).

6. Implementation, Training Protocols, and Data Handling

Training regimes involve standard or customized optimization protocols, usually with AdamW and explicit learning rate schedules. Losses may be standard MSE, regularized with physical constraints, or variational plus CRPS for ensemble emulators. Data is often partitioned into input–output or autoregressive sequences, with dynamic and static node features normalized separately (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).

Open-source codebases, often built on PyTorch, and publicly available simulation datasets (e.g., on HuggingFace or project GitHub repos) enable reproducibility. Graph construction and handling pipelines are designed to support unstructured meshes, adaptive refinement, or multi-level DAGs with minimal code changes.

7. Current Limitations and Extensions

Despite significant progress, several challenges persist:

• Boundary conditioning: Integration of dynamic boundary conditions, e.g., from real-time solar wind monitors, necessitates careful graph boundary masking and features (Holmberg et al., 18 Jan 2026, Holmberg et al., 23 Sep 2025).
• Under-dispersion: VAE-style ensemble models may systematically under-represent uncertainty (spread–skill ratio $\sim0.2{-}0.3$) in high-dimensional fields (Holmberg et al., 18 Jan 2026).
• Long-term rollouts: Error accumulation can degrade small-scale fidelity, especially in under-resolved regimes or for out-of-plane components explicit in the physical model dimensionality (Holmberg et al., 18 Jan 2026).
• Scaling beyond proof-of-principle: Hardware-accelerated approaches (polaritonic lattices) are constrained by fabrication and control overheads for large graphs ($\lesssim50$ spots at present) (Wang et al., 14 Jul 2025).

Extensions proposed in the literature include learnable prototype banks, dynamic/attention-based prototype selection, tighter physical constraints (e.g., mass conservation), and direct physics integration (e.g., differentiable solvers or Hamiltonian constraints in the message passing) (Keshtmand et al., 24 Apr 2025, Martinkus et al., 2020). Quantum photonic variants and adaptive time-integration at the graph level constitute emerging avenues.

---

Principal References: (Keshtmand et al., 24 Apr 2025, Holmberg et al., 23 Sep 2025, Holmberg et al., 18 Jan 2026, Martinkus et al., 2020, Ji et al., 2021, Wang et al., 14 Jul 2025)