---
title: 'LD-GCN: Latent Dynamics for Model Reduction'
url: https://www.emergentmind.com/topics/latent-dynamics-graph-convolutional-network-ld-gcn
type: topic
---

# LD-GCN: Latent Dynamics for Model Reduction

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 [2601.11259].

## 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 [2601.11259].

Source: https://www.emergentmind.com/topics/latent-dynamics-graph-convolutional-network-ld-gcn