LD-GCN: Latent Dynamics for Model Reduction

• LD-GCN is a data-driven architecture that uses a latent neural ODE and graph convolutional decoder to achieve model order reduction on unstructured meshes.
• The method employs a two-branch design where the latent dynamics evolve causally with explicit Euler integration and are decoded to high-dimensional solution fields.
• Empirical results demonstrate LD-GCN’s ability to reduce errors compared to prior approaches, with theoretical guarantees and effective zero-shot prediction via latent interpolation.

The Latent Dynamics Graph Convolutional Network (LD-GCN) is a data-driven, encoder-free neural architecture tailored for nonlinear model order reduction (MOR) of parameterized and time-dependent partial differential equations (PDEs) on unstructured meshes. LD-GCN combines a global, low-dimensional latent representation of system dynamics with graph convolutional decoding to reconstruct high-dimensional solution fields, advancing the latent state causally in time through a neural ODE. This approach explicitly conditions the reduced dynamics on physical and geometric parameters, achieves interpretability of latent trajectories, provides zero-shot prediction via latent interpolation, and supports rigorous theoretical guarantees under precise mathematical assumptions (Tomada et al., 16 Jan 2026).

1. Architectural Fundamentals

LD-GCN employs an encoder-free construction in which the latent state $\bm s(t;\bm\mu)\in\mathbb R^n$ is initialized as $\bm s(0;\bm\mu)=\bm0$, without mapping the field into latent space via a separate encoder. The network advances the latent state in time through a neural ordinary differential equation (NODE), leveraging a two-branch design:

• Latent-dynamics branch ("NN-dyn"): Implements a fully connected neural ODE, computing $$\dot{\bm s}(t)=\mathrm{NN}_{\rm dyn}(t,\bm s(t),\bm\mu(t))$$ with explicit Euler integration.
• Graph-convolutional decoder ("NN-dec"): Given $(t,\bm s(t),\bm\mu(t))$, reconstructs the full-order field $$\bm u_\text{sim}(t;\bm\mu)\in\mathbb R^{N_h\times d_u}$$ on mesh $\mathcal M(\mathcal V,\mathcal E)$ using a small MLP bottleneck, two MoNet-based graph convolutional layers with $n_{\rm hc}$ hidden channels and ELU activations, and a final linear read-out per node.

This encoder-free causal formulation ensures that the evolution of the latent state is entirely governed by the NODE and external parameters, allowing for direct interpretability and time extrapolation.

2. Latent Dynamics Formulation

LD-GCN models system dynamics in the latent space via a continuous neural ODE,

$$\frac{d}{dt}\,\bm s(t)=\mathrm{NN}_{\rm dyn}\bigl(t,\;\bm s(t),\;\bm\mu(t)\bigr),\quad\bm s(0)=\bm0,$$

with high-dimensional solution field decoded as

$$\bm u_\mathrm{sim}(t;\bm\mu)=\mathrm{NN}_{\rm dec}\bigl(t,\;\bm s(t),\;\bm\mu(t)\bigr).$$

In practical implementations, time is discretized using explicit Euler steps:

$$\bm s(t_{j+1})=\bm s(t_j)+\Delta t\,\mathrm{NN}_{\rm dyn}(t_j,\bm s(t_j),\bm\mu(t_j)).$$

Both temporal ($t$) and parameter ($\bm\mu(t)$) dependencies are explicitly input to $\mathrm{NN}_{\rm dyn}$ (and optionally $\mathrm{NN}_{\rm dec}$), enabling the latent state to respond to external forcing and parameter variations.

3. Mathematical Guarantees

The LD-GCN construction admits a universal approximation result for encoder-free architectures (Corollary 3.1), under the assumption of perfect latent embedding:

• There exists a sufficiently expressive latent NODE $\mathcal{NN}_{\rm dyn}$ and graph decoder $\mathcal{NN}_{\rm dec}$ such that, for any $\varepsilon>0$, integration step $\Delta t^*$, and all $\Delta t\leq\Delta t^*$, the network can approximate the full-order solution $\bm u_h(\cdot;\bm\mu)$ within $\varepsilon$ at all time steps and parameter points:

$$\sup_{k=1,\dots,N_t}\;\|\bm u_h(t_k;\bm\mu)-\bm u_\text{sim}(t_k;\bm\mu)\|\leq\varepsilon,$$

where the simulated field is computed as

$$\bm u_\mathrm{sim}(t_k;\bm\mu)=\mathcal{NN}_\mathrm{dec}\Bigl(\Delta t\sum_{j=0}^k\omega_j\,\mathcal{NN}_\mathrm{dyn}(t_j,\bm\mu)\Bigr).$$

Assumptions: fixed initial conditions, smooth decoder existence, Lipschitz continuity, and time-constant signals (extensions to fully time-varying forcing remain open).

4. Training and Optimization Protocol

LD-GCN is trained using a composite loss: $$\mathcal L(\bm w)=\mathcal L_{\rm err}(\bm u_h,\bm u_\text{sim})+\lambda\|\bm w\|_1,$$ where $\mathcal L_{\rm err}$ denotes mean squared error (MSE), supplemented with a directional-alignment term $\mathcal L_\varepsilon$ (weighted by $\delta=10^{-1}$) for Navier–Stokes cases. $L^1$ weight decay is applied with strength $\lambda=10^{-5}$.

Training proceeds via:

• Initial Adam optimization (200–1500 epochs)
• Final refinement using L-BFGS (200 steps)
• Backpropagation through the latent-ODE integration loop

Data requirements entail assembling a training set $\mathcal T_{\rm train}\subset I\times P$; the latter portion (typically last 25–50%) of each trajectory is withheld to test time extrapolation. Solution snapshots are affinely normalized per node and no scaling is applied to $t$ or $\bm\mu$.

5. Zero-Shot Prediction and Latent Interpolation

LD-GCN supports zero-shot prediction by constructing explicit interpolants of latent trajectories $\tilde{\bm s}(t;\bm\mu)\approx\bm s(t;\bm\mu)$ over the training mesh, which are decoded via the trained NN-dec. Two interpolation methods are employed:

• Degree-1 multivariate splines (support interpolation only)
• Gaussian process regression (GPR) with Matérn $\nu=1.5$ kernel (supports extrapolation in $t$ and $\bm\mu$)

Proposition 3.3 establishes the error bound for reconstructed fields using latent interpolation: $$\|\bm u_h(t;\bm\mu)-\bm u_\text{interp}(t;\bm\mu)\|\leq L\,\delta(m)+\varepsilon(t;\bm\mu),$$ where $L$ is the Lipschitz constant of NN-dec and $\delta(m)$ the maximal discrepancy in latent space interpolation. As $\delta(m)\to0$, the surrogate approaches full LD-GCN accuracy.

Two practical strategies for handling unseen $(t,\bm\mu)$ points are outlined:

1. Integrate-then-interpolate: advance all latent trajectories then interpolate.
2. Interpolate-then-extrapolate: build a GPR directly on latent space and query new input pairs.

6. Empirical Results on Benchmark Problems

LD-GCN has been evaluated across several computational mechanics benchmarks:

Benchmark	Mesh Nodes ($N_h$)	Latent Dim ($n$)	Mean Rel. Error	Max Rel. Error	Prior Approach (GCA) Error
SA (advection)	1472	3	$7.86 \times 10^{-3}$	$5.26 \times 10^{-2}$	$1.87 \times 10^{-2}$ (mean)
MH (moving hole)	1352	15	$8.81 \times 10^{-3}$	$1.02 \times 10^{-1}$	$3.54 \times 10^{-2}$ (mean)
Lid cavity (NS)	10024	3	NRMSE $6.79 \times 10^{-3}$	—	LD-Net NRMSE $1.39 \times 10^{-3}$ $(n=10)$
Coandă effect (NS)	—	—	$4.57 \times 10^{-3}$	$3.62 \times 10^{-2}$	—

For advection–diffusion benchmarks (SA and MH), LD-GCN achieves lower relative errors over GCA, demonstrates robust handling of geometric parameters, and encodes smooth, interpretable latent trajectories. In Navier–Stokes problems (lid cavity, Coandă effect), LD-GCN reproduces complex phenomena including bifurcation diagrams and tracks time-dependent boundary forcing via latent variables.

Zero-shot predictions via GPR and splines on the SA benchmark yield comparable error profiles; GPR affords natural extrapolation capabilities.

7. Implementation Specifications

Reference code is available at https://github.com/lorenzotomada/ld-gcn-rom.

Architectural details for NN-dyn (latent dynamics MLP):

• SA/MH/Coandă: five layers with widths $[n+2, 80,\dots, 80, n]$ or $[n+1, 50,50, n]$
• Lid cavity: seven layers $[n+2, 100, 100, 100, 100, 100, n]$
• Activation: tanh

Graph decoder (NN-dec):

• Two-layer MLP projecting $(t,\bm s,\bm\mu)$ to $\mathbb R^{N_h\times n_{\rm hc}}$; $n_{\rm hc}=2$
• Two MoNet graph-convolutional layers with ELU activations and skip-connections
• Final linear layer for $d_u$ output per node

Hyperparameters:

• Learning rate $10^{-3}$, $L^1$ weight decay $\lambda=10^{-5}$
• Navier–Stokes extra loss weight $\delta=10^{-1}$, $\varepsilon=10^{-4}$
• Optimizer: Adam (200–1500 epochs) to L-BFGS (200 steps)
• Explicit Euler $\Delta t$ chosen per problem, e.g., 0.5 (SA/MH/Coandă), 0.1 (lid cavity)
• Pre/post-processing: per-node normalization; no scaling of $t$ or $\bm\mu$

This architecture delivers interpretable global latent dynamics, non-intrusive handling of parameterized PDEs on unstructured meshes, direct causal time evolution and extrapolation, and scalability relative to full-order models and prior graph autoencoder-based approaches (Tomada et al., 16 Jan 2026).