acceptodds
Under review as a conference paper at ICLR 2027

GLaDiT: Graph-Local Latent Diffusion Transformer for Flow Generation

Abstract

Predicting unsteady fluid flow on irregular meshes requires resolving coupled velocity and pressure dynamics over extended horizons. While graph-based simulators accommodate unstructured geometries natively, autoregressive rollouts suffer from compounding error accumulation. Conversely, trajectory diffusion models bypass recursive drift but rely on regular Euclidean grids, requiring lossy interpolations that distort mesh connectivity and inflate memory overhead. We introduce GLaDiT (Graph-Local Latent Diffusion Transformer), a graph-native Diffusion Transformer for flow generation. Operating directly on coarse mesh representations via a pretrained graph autoencoder, GLaDiT concurrently refines an entire multi-frame trajectory block in parallel, eliminating intermediate grid projections and recursive error feedback. Within the generative backbone, graph-local spatiotemporal attention pairs 1-hop spatial graph communication with global temporal attention, maintaining sparse per-block computation while structurally permitting domain-wide dependency paths across network depth. Evaluations demonstrate that GLaDiT achieves leading accuracy on most evaluation metrics across multiple datasets, while offering an adjustable compute-accuracy budget and reducing peak inference memory by 18.5× compared to Cartesian grid trajectory diffusion.

Primary area:
generative models
Keywords:
Diffusion Model, Video Generation, Fluid Simulation, Physical Modelling

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_tEQEOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces GLaDiT, a graph-native latent Diffusion Transformer for predicting unsteady fluid trajectories on unstructured meshes. A pretrained, frozen graph autoencoder compresses velocity and pressure fields onto a coarse mesh, where a conditional diffusion model jointly generates future frames rather than advancing them autoregressively. Its main architectural contribution is graph-local spatiotemporal attention: each token attends to all temporal slots within its one-hop spatial neighborhood, while stacked layers expand spatial dependencies. This combines joint trajectory generation with native mesh representations without intermediate Cartesian-grid projections.

Validation covers 64-frame forecasts on transonic airfoil and incompressible cylinder-flow datasets, comparing against MGN, EAGLE, AROMA, and Text2PDE. The reported results show strong airfoil accuracy across field and derivative metrics, competitive cylinder-flow performance, and an 18.5-fold reduction in peak inference memory relative to Text2PDE on Airfoil. Attention and sampling ablations further examine training efficiency and trade-offs between accuracy and inference cost.

Critical strengths
  1. A coherent framework for joint trajectory prediction on unstructured meshes:

GLaDiT combines graph-based latent representations with joint temporal diffusion, avoiding intermediate Cartesian-grid projections and autoregressive feedback within the forecast window. Its graph-local spatiotemporal attention provides a practical mechanism for coupling mesh connectivity with full-window temporal context. This is consequential because it addresses a meaningful limitation of existing approaches while preserving the geometry of the simulation domain.

  1. Evidence of useful accuracy and computational benefits:

On Airfoil, the reported improvements extend beyond velocity and pressure to vorticity, divergence, and enstrophy, supporting the quality of the predicted spatial structure. The framework also reduces peak inference memory by approximately 18.5× relative to Text2PDE, while attention ablations demonstrate substantially faster training updates than full attention. These results strengthen the case that the architectural choices offer practical benefits beyond a conceptual combination of existing components.

Critical weaknesses

1.Limited validation of the claimed benefits for time-related prediction:

The paper motivates GLaDiT by the accumulation of errors in autoregressive prediction, but addresses this issue by jointly generating a fixed temporal block. The experiments evaluate only 64-frame forecasts, which demonstrate performance within that window but do not establish an advantage for substantially longer horizons. In particular, it remains unclear whether accuracy can be maintained when enlarging the prediction window, how the associated computational cost scales, or whether error accumulation reappears when successive blocks are chained. This limits the evidence supporting the paper’s central motivation.

2.Limited benchmark coverage and insufficient comparison with closely related graph generative models:

The evaluation is restricted to two 2D flow benchmarks, Airfoil and CylinderFlow. Although these involve distinct flow regimes, they provide limited evidence that the proposed architecture generalizes across broader geometries, spatial dimensions, and dynamical systems. AROMA evaluates multiple time-dependent PDE settings, while related graph generative methods—including DGN/LDGN (ICLR 2025), PIFM-GN (AAAI 2026), and CGFM (ICML 2026)—provide broader validation across flow tasks and 2D/3D settings. Additional benchmarks would strengthen the evidence for GLaDiT’s applicability.

Furthermore, although GLaDiT adopts the graph autoencoder from LDGN, the empirical comparison lacks a closely related graph diffusion baseline adapted to the same initial-condition-dependent forecasting task. The original DGN/LDGN models target equilibrium-state distributions and are therefore not directly comparable without adaptation. Nevertheless, a suitably conditioned temporal extension using the same latent representation would help isolate the benefit of GLaDiT’s Transformer and graph-local spatiotemporal attention from that of the underlying graph compression. Without such a comparison, the incremental contribution over existing graph generative architectures remains insufficiently established.

Questions for authors

Is GLaDiT intended only for a fixed 64-frame forecast window, or can it support substantially longer predictions through larger windows or successive prediction blocks? If longer-horizon evaluations are available, do they show a sustained advantage over autoregressive baselines at comparable inference cost? This would help determine whether the reported benefit extends beyond joint prediction within the evaluated window.

3 comments
AuthorsOpenReview ↗

Response to Reviewer tEQE

Thank you for your careful review and constructive feedback.

Longer prediction horizons and matched-cost comparisons

Generating 64-frame blocks eliminates intra-window drift and reduces long-horizon autoregressive handoffs by 64× at linear compute cost. Within the 64-frame window, stepwise rollouts accumulate severe error across 64 recursive feedbacks: MGN's error rises 3.3× from frame 24 to frame 64 on Airfoil and 1.9× on CylinderFlow. A single GLaDiT pass instead achieves the lowest frame-64 validation error on both benchmarks (Tables 18 and 24) and beats four-sample AROMA on Airfoil at comparable latency (1.41% in 2.85 s vs. 1.60% in 2.15 s, Table 11; CylinderFlow latencies in Tables 10 and 13).

For extended horizons 64mΔt64m\Delta t, semigroup composition (ΦmH=ΦH∘m\Phi_{mH}=\Phi_H^{\circ m}; "Longer prediction horizons" in our General Response and Section 7) chains mm blocks with only mm handoffs instead of 64m64m stepwise feedbacks, keeping compute O(m)O(m) and attention memory constant rather than O((mH)2)O((mH)^2). Because both official benchmarks store only 75 stride-8 frames per trajectory (e.g., 6 s total vs. 5.12 s per block on CylinderFlow) and lack a second 64-frame target block, multi-block training with noisy-history conditioning requires longer trajectory datasets left to future work.

Broader benchmarks and geometric coverage

Held-out test evaluations and 1,200-mesh CylinderFlow variation establish generalization across flow regimes and unstructured discretizations. On the official 100-trajectory test sets of all external baselines (Table 28; reproduced in our Response to Reviewer 83gV), GLaDiT achieves the lowest Airfoil test error (1.3771% vs. 1.5643% for AROMA). These held-out results confirm generalization from incompressible vortex shedding to compressible transonic shocks.

Moreover, GLaDiT is not restricted to a single fixed mesh: all 1,200 CylinderFlow trajectories have distinct unstructured meshes (1,732 to 2,059 physical nodes, 3,226 to 3,884 cells, and 118 to 156 coarse nodes) alongside varying cylinder positions and radii ("Mesh variation and geometric coverage" in our General Response). Extending this graph-native framework to multi-shape pretraining (cf. equilibrium generators such as LDGN, PIFM-GN, and CGFM), additional PDE families (such as AROMA's periodic scalar or spherical tasks), and 3D aerodynamics requires dedicated representation pretraining and matched corpora left to future work.

Conditioned temporal graph-diffusion baseline

GLaDiT's gains come from explicit spatiotemporal attention rather than the shared autoencoder. Adapting LDGN, Temporal GNN diffusion shares our frozen representation, initial state, diffusion loss, and sampling budget (Section 6.3). GLaDiT cuts test UV error from 15.0585% to 7.4636% on CylinderFlow (-50.44%) and from 1.9431% to 1.3771% on Airfoil (-29.13%) (Table 2).

This gap reflects a structural modeling bottleneck in channel-stacked GNNs. Extending static LDGN to trajectories stacks the 64 future frames into node-feature channels of a multiscale graph U-Net, mixing time only through local MLP channel projections without cross-time token attention. On Airfoil, even after the temporal GNN's training loss and validation error fully plateau (Figure 13), its test error remains stuck at 1.9431% (worse than EAGLE's 1.8741%, Table 28), demonstrating that explicit spatiotemporal token attention across time and graph neighborhoods is essential to unlock latent trajectory diffusion.

I thank the authors for their detailed rebuttal and additional clarifications. However, after carefully considering both the individual response and the general response, I find that my main concerns remain insufficiently addressed. Therefore, I have decided to maintain my original assessment and score.

First, the central concern regarding long-horizon prediction remains unresolved. The authors emphasize that generating 64-frame blocks reduces the number of autoregressive handoffs and allows computational cost to scale linearly with the prediction horizon. However, reducing the number of handoffs does not necessarily prevent error accumulation across successive prediction blocks. The proposed block-wise composition is supported by theoretical arguments rather than direct experimental evidence. As the authors acknowledge, multi-block prediction and evaluation remain future work. Consequently, the reported results demonstrate the advantages of joint prediction within a fixed 64-frame window, but do not establish that these advantages persist over substantially longer horizons.

Second, the experimental validation remains limited in scope. I acknowledge the additional clarification regarding variations in mesh topology, cylinder position, and radius. Nevertheless, these variations primarily demonstrate generalization within the same problem family, rather than across substantially different geometries, PDE systems, or spatial dimensions. The broader applicability of the proposed framework therefore remains insufficiently established.

Third, I appreciate the clarification regarding the Temporal GNN diffusion baseline and the additional architectural ablations. These comparisons provide useful evidence for the contributions of the proposed components and partially address my concern regarding related graph generative architectures. However, they do not resolve the limitations concerning long-horizon prediction and broader validation.

Overall, while the rebuttal provides useful clarifications and supporting results, it does not fundamentally change my assessment of the paper's main limitations. I therefore maintain my original score.

Thank you for your thoughtful follow-up. While we appreciate your perspective, the concerns raised regarding multi-block forecasting and cross-domain transfer evaluate a different problem formulation than the one investigated in this paper. Our central research question is whether a generative model can jointly synthesize an entire flow trajectory on its native unstructured mesh from a single observed initial state. The conditioned temporal GNN ablation you acknowledged directly isolates and confirms our denoiser contribution for this task.

Forecast horizon. GLaDiT predicts all 64 future frames jointly and achieves the lowest frame-64 validation velocity error among all evaluated methods on both benchmarks (Tables 18 and 24). Evaluating recursive error accumulation across chained blocks fundamentally changes the task from initial-state forecasting to autoregressive rollout on model-predicted states. Doing so rigorously requires substantially longer reference trajectories and matched-cost baselines trained for extended horizons. Even two consecutive blocks require 129 frames including the initial condition, whereas both official benchmarks contain only 75 frames and offer no baseline reference for multi-block handoffs. Consequently, the 64-frame benchmark is the exact, scientifically appropriate testbed for our single-window claims.

Geometric and physical scope. On CylinderFlow, a single trained model generalizes to unseen meshes across a 1,200-mesh family with varying topologies, cylinder positions, and radii, while Airfoil evaluates the same architecture on transonic compressible flow with shock waves. Expanding validation across arbitrary obstacle families, distinct PDE systems, or three-dimensional domains would require substantial resources to curate new datasets, redesign mesh representations, and train matched baselines for every setting, efforts that lie beyond the scope of a focused academic study. Treating exhaustive cross-domain coverage as a prerequisite conflates follow-up engineering scale with the core methodological contribution already demonstrated here: joint trajectory diffusion on native unstructured meshes across two distinct flow regimes.

Reviewer_G8yuOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes GLaDiT, a graph-based latent diffusion transformer for fluid flow generation on irregular meshes. The method uses a pretrained graph autoencoder to represent flow fields on coarse meshes, and jointly generates future trajectories through diffusion with graph-local spatiotemporal attention. Experiments on Airfoil and CylinderFlow show good prediction accuracy, especially on Airfoil, and significantly lower inference memory compared to grid-based trajectory diffusion.

Critical strengths
  1. The problem is meaningful. Combining graph-based representations with non-autoregressive trajectory prediction is a reasonable direction for fluid simulation on irregular meshes.

  2. The results on Airfoil are quite good, with improvements in velocity, pressure, and several physical metrics. The long-horizon prediction results are also encouraging.

  3. The paper provides detailed experiments and ablations, especially on attention mechanisms, training efficiency, and sampling budgets. The graph-local attention shows clear advantages in training throughput compared to full attention.

Critical weaknesses
  1. The technical novelty seems somewhat limited. The main method is a combination of existing graph autoencoder, joint trajectory diffusion, and local graph attention. While this combination is reasonable, I am not sure what is fundamentally new here beyond adapting existing methods to graph-based trajectory generation. The receptive-field analysis also mainly shows that stacking local attention layers allows information to propagate over more graph hops, which is a known property of graph neural networks.

  2. I am not convinced that diffusion is necessary for the reported improvements. The paper argues that joint trajectory generation avoids error accumulation from autoregressive prediction, which makes sense. However, a deterministic graph transformer that directly predicts the whole future trajectory could also achieve this without diffusion. I think a very important missing baseline is to use the same graph autoencoder and spatiotemporal transformer, but directly predict all future frames with a regression loss. Without this comparison, it is hard to tell whether the gains come from diffusion, joint temporal modeling, or simply a better graph representation.

  3. The generative modeling aspect is not sufficiently evaluated. Most results focus on pointwise prediction errors, and the main evaluation uses the mean of multiple generated trajectories. This is reasonable for improving RMSE, but does not really demonstrate that the model learns an accurate distribution of fluid trajectories. In fact, Table 12 shows that averaging improves velocity and pressure errors but can make the enstrophy error worse. I would like to see more direct evaluation of individual generated trajectories and their physical statistics. Otherwise, the benefit of using a generative model rather than a deterministic predictor remains unclear.

  4. The generality and practical efficiency of the method are not fully demonstrated. The method performs well on Airfoil, but the results on CylinderFlow are more mixed, with several baselines achieving better overall velocity accuracy. Both benchmarks also use fixed mesh topologies and fixed prediction windows, so it is unclear how well the method generalizes to different meshes or longer horizons. The reported 18.5× memory reduction compared with Text2PDE is useful, but the inference latency is substantially higher than other baselines. Therefore, I think the practical advantage of this approach needs to be better justified.

Questions for authors
  1. Have the authors considered a deterministic joint trajectory predictor using the same graph autoencoder and graph-local transformer, but without diffusion? I think this would be important to clarify the actual contribution of diffusion.

  2. Can the authors provide more evaluation of the generated trajectory distribution, rather than mainly the averaged prediction? For example, how well do individual samples preserve physical statistics and temporal dynamics?

  3. Can the authors further clarify the practical advantage of GLaDiT given its higher inference latency? Also, would the method generalize to unseen mesh geometries or prediction horizons longer than the training window?

3 comments
AuthorsOpenReview ↗

Response to Reviewer G8yu

Thank you for your careful review and constructive feedback.

Combination novelty and one-hop attention

GLaDiT's three core choices are jointly necessary. Under matched budgets, removing diffusion raises test UV error by up to 34.03%, while replacing the Transformer with a temporal GNN raises error by 41.10% to 101.76% (Table 2; "Diffusion and architectural controls" in our General Response). Within the same Transformer, our one-hop mask speeds up Airfoil training by 9.7× over full attention (1.06 s vs. 10.33 s per update on four H20 GPUs; Section 6.4, Tables 7 and 8). Appendix A.2 verifies that depth (SLh=144≫diam⁡(Gℓ)∈[15,21]SLh=144 \gg \operatorname{diam}(\mathcal{G}_\ell) \in [15, 21]) preserves domain-wide dependency paths for elliptic pressure coupling without claiming multi-hop propagation itself as novel.

Diffusion versus deterministic joint prediction

Diffusion regularizes joint trajectory learning and outperforms the parameter-matched deterministic Transformer on both datasets. Sharing the frozen autoencoder, 24-block Transformer, and 115.01M parameters, GLaDiT w/o diffusion overfits after 25k updates on CylinderFlow (Figure 14). Diffusion reduces test UV error by 25.39% at 250k updates (22.58% even against the regression model's best 25k checkpoint) and improves all eight CylinderFlow test physical metrics, reducing the error metrics by 10.4% to 30.1% (Tables 2 and 17). On Airfoil, despite the nearby 1.29% autoencoder floor (Table 4), diffusion lowers test UV error by 1.16% and cuts test divergence RMSE by 17.48% (Table 17), confirming the perturbation-recovery regularization derived in Appendix A.5.

Individual trajectories and physical statistics

Individual GLaDiT realizations (K=1K=1) already preserve accurate physical fields and full-history integral dynamics without ensemble averaging. Across full 64-frame series on Airfoil, one GLaDiT sample beats single-sample AROMA on velocity, pressure, vorticity, divergence, and enstrophy (Table 14), and even outperforms its 16-sample ensemble in UV error (Table 12). On CylinderFlow, a single GLaDiT sample achieves the lowest enstrophy error of any method (0.0304, Table 23) and resolves sharp vortex and shock structures over time (Figures 20 to 26).

Unlike deterministic regression, which is locked to a single conditional-mean operating point, generative test-time scaling lets users choose between realization sharpness and pointwise precision. Convex field averaging damps small-scale rotational variance. Single realizations (K=1K=1) therefore achieve lower enstrophy error on Airfoil (11.89% vs. 14.14% at K=8K=8, Table 14) and CylinderFlow (3.04% vs. 3.21%, Table 23), whereas K=8K=8 minimizes velocity, pressure, and derivative RMSE. Fixed pretrained weights serve both regimes on demand by varying KK.

Practical inference latency, mesh variation, and longer horizons

Training-free test-time scaling makes GLaDiT practical at low latency, and one model already generalizes across 1,200 distinct CylinderFlow meshes. Lowering the Airfoil budget to S=3,K=1S=3, K=1 reaches 1.41% UV error in 2.85 s, beating four-sample AROMA (1.60% in 2.15 s, Table 11); Section 6.2 clarifies that the 18.5× memory reduction is relative to Text2PDE. Across CylinderFlow, a single GLaDiT model handles unseen meshes spanning 1,732 to 2,059 nodes with varying cylinder centers and radii ("Mesh variation and geometric coverage" in our General Response). For horizons beyond 64 frames, block chaining cuts autoregressive handoff points by 64× at linear compute cost ("Longer prediction horizons" in our General Response; Section 7).

Can the authors report K=1 results for the matched 250K diffusion checkpoints, and clarify whether the deterministic regression baseline was independently tuned for regularization? Also, the temporal GNN has substantially fewer parameters than the Transformer, so I am not sure this ablation isolates the architectural contribution.

Single-sample results at 250k updates. Thank you for requesting this comparison. The table below reports velocity relative RMSE (%) over 64 forecast frames using the matched 250k checkpoints (EMA decay 0.999) across 100 equally weighted trajectories per split. Both diffusion models use six DDIM steps per sample. To evaluate individual realizations without field averaging, we score three independent single samples (K=1K=1) separately per trajectory and average their resulting errors; the deterministic Transformer produces one forecast per trajectory.

ModelCylinderFlow validationCylinderFlow testAirfoil validationAirfoil test
GLaDiT (K=1K=1)8.35428.66221.40631.4158
Deterministic Transformer9.435110.00381.38561.3933
Temporal GNN diffusion (K=1K=1)17.301617.80492.39342.3485

On CylinderFlow, individual GLaDiT samples achieve the lowest velocity error on both splits. On Airfoil, deterministic regression holds a 0.0225 percentage-point advantage in test velocity error, whereas individual GLaDiT samples achieve 10.77% lower divergence RMSE and 4.62% lower enstrophy relative RMSE on the same test trajectories.

With the same fixed weights, GLaDiT enables training-free test-time scaling via physical-field averaging (K=8K=8), which reduces test velocity error to 7.4636% on CylinderFlow and 1.3771% on Airfoil (Table 2). On Airfoil, this test-time-scaled prediction outperforms deterministic regression across velocity, pressure, vorticity, and divergence (Tables 2 and 17), allowing users to trade inference budget for higher predictive accuracy without retraining.

Regression regularization. Both Transformer models share the same optimization and regularization settings—AdamW with weight decay 10−610^{-6} and zero dropout—without an independent regularization search for regression. We also evaluated early stopping on CylinderFlow: regression attains its lowest validation velocity error at 25k updates, yielding 9.6401% test error, which remains above the 8.6622% single-sample test error of the 250k GLaDiT checkpoint.

Temporal GNN capacity. Because the initial ablation changed both the denoiser architecture and its parameter count, we trained three wider temporal GNNs on Airfoil while holding fixed the frozen graph representation, diffusion objective, 250k-update budget, and single-sample (K=1K=1) evaluation protocol. Parameter counts below refer to the trainable denoiser, and errors are velocity relative RMSE (%).

Airfoil denoiserParametersValidationTest
Temporal GNN, width 1282.48M2.39342.3485
Temporal GNN, width 2569.42M1.99931.9455
Temporal GNN, width 51236.86M1.77571.7228
Temporal GNN, width 1024146.00M1.76921.7126
GLaDiT Transformer115.01M1.40631.4158

Widening the temporal GNN reduces error, with diminishing returns between widths 512 and 1024, yet the Transformer maintains lower error on both splits even when the GNN has more parameters (146.00M vs. 115.01M). This supports the spatiotemporal Transformer denoiser on Airfoil, while Section 6.4 separately isolates the one-hop attention mask within the same Transformer.

Reviewer_83gVOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes GLaDiT, a graph-native latent diffusion framework for generating fluid trajectories on irregular meshes. The method combines a pretrained graph autoencoder with a diffusion transformer using local spatial attention and global temporal interactions. Experiments on Airfoil and CylinderFlow assess prediction accuracy, physical statistics, and computational efficiency.

Critical strengths
  • The framework enables trajectory diffusion directly on coarse graph representations, avoiding intermediate projections onto Cartesian grids.

  • The evaluation investigates spatial attention design, diffusion sampling budgets, and computational costs, providing useful information about the accuracy-efficiency trade-off.

Critical weaknesses
  • GLaDiT uses approximately 177M parameters, compared with roughly 2M for AROMA. On CylinderFlow, its reported velocity error (0.0725) is higher than those of MGN (0.0612) and AROMA (0.0634). Moreover, the reported 18.5× memory reduction is measured against Cartesian-grid trajectory diffusion and does not establish superior efficiency relative to graph-based or latent-space alternatives. The computational cost is not adequately justified by the predictive gains.

  • The framework combines pretrained graph representations, a transformer backbone, and iterative diffusion sampling. However, the evaluation does not isolate the benefit of diffusion against direct multi-frame prediction using the same graph latent space and a comparable backbone. In addition, the principal results are reported on validation trajectories, leaving generalization to an independent test set insufficiently established. The necessity of diffusion-based trajectory generation remains unclear.

Questions for authors
  • How does GLaDiT compare with a direct multi-frame prediction model using the same pretrained graph autoencoder and transformer backbone? What accuracy gains can be attributed specifically to diffusion-based generation?

  • Can the authors provide independent test-set results and matched end-to-end accuracy-latency comparisons against AROMA and MGN? In particular, how is the additional computational cost justified on CylinderFlow, where the velocity prediction error is higher?

3 comments
AuthorsOpenReview ↗

Response to Reviewer 83gV

Thank you for your careful review and constructive feedback.

Diffusion versus direct joint prediction

Diffusion delivers consistent accuracy and physical-fidelity gains over a parameter-matched joint regression Transformer on both benchmarks. Both models share the frozen graph autoencoder, 24-block Transformer (115.01M parameters), and 64-frame task. Diffusion lowers test UV error by 25.39% on CylinderFlow (22.58% even against the regression model's optimal 25k validation checkpoint) and by 1.16% on Airfoil (Table 2). Crucially, diffusion improves all eight CylinderFlow test physical metrics, reducing the error metrics by 10.4% to 30.1%, and cuts Airfoil test divergence RMSE by 17.48% near the 1.29% autoencoder floor (Tables 4 and 17), matching the noisy-input regularization proved in Appendix A.5 ("Diffusion and architectural controls" in our General Response).

CylinderFlow accuracy, cost, and model capacity

Model capacity reflects the joint 64-frame generation paradigm, unlocking shock-resolving accuracy that compact transition models cannot reach even with 16× sampling. Generating a 64-frame spatiotemporal block in parallel requires higher capacity than a single-step transition. GLaDiT's 177.37M total parameters match Cartesian-grid joint diffusion (Text2PDE, 198.20M) while cutting peak inference memory by 18.5× via coarse graph latents (1,483 vs. 27,381 MiB, Table 1; Section 6.2 notes that 2.00M-parameter AROMA has a smaller footprint).

On regular periodic vortex shedding (CylinderFlow), compact transition models suffice for full-window UV accuracy and faster inference (0.66 s for MGN and 0.50 s for single-sample AROMA, vs. 1.62 s for single-sample GLaDiT; Tables 10 and 13). Even there, GLaDiT achieves the lowest final-frame validation error and lowest single-sample enstrophy error (0.0304; Tables 23 and 24). On transonic shock-boundary-layer interactions (Airfoil), however, scaling AROMA to K=8K=8 (4.32 s) or K=16K=16 (8.35 s) plateaus at 1.60% UV error (Table 12), whereas a single three-step GLaDiT sample reaches 1.41% in 2.85 s (Table 11), strictly improving both speed and accuracy over larger AROMA ensembles.

Independent test results

Held-out evaluations across all external baselines and ablations confirm consistent cross-dataset trends on the official 100-trajectory test sets. Table 28 evaluates MGN, EAGLE, AROMA, and Text2PDE with their validation-selected checkpoints and native sampling protocols (Appendix D.3), alongside the 250k GLaDiT checkpoints from Table 2. Validation-selected 550k CylinderFlow and 200k Airfoil checkpoints score 7.5246% and 1.3812%, preserving GLaDiT's relative standing across both benchmarks. Below are test UV relative errors (%, best, second-best).

ModelCylinderFlow TestAirfoil Test
MGN6.57594.6079
EAGLE9.00471.8741
AROMA6.05521.5643
Text2PDE8.78923.0042
GLaDiT7.46361.3771

GLaDiT achieves the lowest Airfoil test error among all methods, while AROMA and MGN retain lower full-window test UV error on CylinderFlow.

End-to-end accuracy and latency comparison

Training-free test-time scaling lets GLaDiT outperform four-sample AROMA on Airfoil at comparable end-to-end latency. On one H20 GPU (including encoding, generation, decoding, and CPU-to-GPU transfers; Table 11, Appendix D.3), reducing the inference budget to S=3,K=1S=3, K=1 cuts latency by more than 10× while retaining lower error than every baseline:

Model and configurationTime (s) ↓UV relative error (%) ↓
GLaDiT, S=3S=3, K=1K=12.851.41
AROMA, K=4K=42.151.60
Text2PDE, K=2K=21.593.06
MGN0.664.70
GLaDiT, S=6S=6, K=8K=830.771.37

Varying SS and KK at test time smoothly trades inference compute for predictive precision with fixed weights ("Accuracy, latency, and test-time scaling" in our General Response).

Thank you for your response. I have carefully read the rebuttal and appreciate your clarifications.

Thank you for taking the time to read our rebuttal and consider our clarifications.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank the reviewers for their constructive feedback. Manuscript revisions are marked in blue.

Diffusion and architectural controls

GLaDiT is the first to establish experimentally the complementary value of diffusion and graph-local spatiotemporal Transformers for initial-state-conditioned joint flow-trajectory generation on native unstructured meshes. Removing either diffusion or the spatiotemporal Transformer degrades accuracy on both benchmarks.

Table 2 isolates each component on the same frozen graph autoencoder and 250k-update budget. GLaDiT w/o diffusion keeps the 24-block Transformer (115.01M parameters) in one regression pass; Temporal GNN diffusion uses a multiscale graph U-Net. Generative models use six DDIM steps and eight-sample field averaging (UV relative error %, best, second-best).

ModelCylinderFlow ValidationCylinderFlow TestAirfoil ValidationAirfoil Test
GLaDiT7.16337.46361.36911.3771
GLaDiT w/o diffusion9.435110.00381.38561.3933
Temporal GNN diffusion14.636915.05852.00231.9431

Diffusion prevents trajectory-regression overfitting and improves physical consistency beyond removing rollout feedback. Direct regression overfits after 25k updates on CylinderFlow (Figure 14). Diffusion cuts 250k test UV error by 25.39%, beats the best 25k regression checkpoint (9.6401% test error) by 22.58%, and improves all eight CylinderFlow test physical metrics, reducing the error metrics by 10.4% to 30.1% (Table 17). On Airfoil, despite the 1.29% autoencoder floor (Table 4), diffusion lowers test UV error by 1.16% and cuts test divergence RMSE by 17.48% (3.9907 to 3.2931 s−1\mathrm{s}^{-1}, Table 17). Appendix A.5 (Equations 14 to 17) proves that noisy-input recovery penalizes perturbation sensitivity, matching the 20-checkpoint curves in Appendix E.5.

Accuracy, latency, and test-time scaling

Physical-field averaging (KK) and denoising steps (SS) enable training-free test-time scaling, beating multi-sample baselines at comparable latency on shock-dominated flow. Lowering the Airfoil budget to S=3,K=1S=3, K=1 reaches 1.41% UV error in 2.85 s on one H20 GPU, beating four-sample AROMA (1.60% in 2.15 s, Table 11). On CylinderFlow, MGN (0.66 s) and AROMA (0.50 s at K=1K=1, 4.01 s at K=8K=8; Table 13) retain lower full-window UV error and latency. GLaDiT instead achieves the lowest final-frame validation error and lowest single-sample enstrophy error of 0.0304 in 1.62 s (vs. 13.02 s at K=8K=8; Tables 10, 23, and 24). Relative to grid diffusion (Text2PDE), GLaDiT cuts peak inference memory by 18.5× on Airfoil (1,483 vs. 27,381 MiB, Table 1), while AROMA uses less memory.

Longer prediction horizons

Blockwise generation cuts autoregressive handoff boundaries by 64× while keeping compute linear in horizon length. Across 64 frames, stepwise baselines run 64 recursive rollouts and suffer severe drift: MGN's error grows 3.3× from frame 24 to frame 64 on Airfoil and 1.9× on CylinderFlow. A single GLaDiT block instead achieves the lowest frame-64 validation error on both benchmarks (Tables 18 and 24). For longer autonomous horizons mHmH (H=64ΔtH=64\Delta t), evolution-operator composition gives

ΦH=ΦΔt∘64,ΦmH=ΦH∘m,\Phi_H=\Phi_{\Delta t}^{\circ 64},\qquad \Phi_{mH}=\Phi_H^{\circ m},

so forecasting 64m64m frames requires only mm block handoffs rather than 64m64m stepwise feedbacks, following operator composition (Herde et al., NeurIPS 2024, Poseidon), temporal bundling (Brandstetter et al., ICLR 2022, MP-PDE), and window diffusion (Ruhe et al., ICML 2024, Rolling Diffusion). Chaining fixed-length blocks keeps compute O(m)O(m) at constant attention memory, avoiding quadratic O((mH)2)O((mH)^2) window growth, while noisy-history training can mitigate handoff error (Chen et al., NeurIPS 2024, Diffusion Forcing; Section 7). Because both official benchmarks store only 75 stride-8 frames per trajectory (e.g., 6 s total vs. 5.12 s per block on CylinderFlow), multi-block training and evaluation require longer datasets left to future work.

Mesh variation and geometric coverage

One trained GLaDiT model generalizes across unseen unstructured mesh topologies, obstacle positions, and radii. All 1,200 CylinderFlow trajectories use distinct meshes: 1,732 to 2,059 nodes and 3,226 to 3,884 cells (validation: 1,748 to 2,057 nodes; test: 1,757 to 2,040). Coarse graphs span 118 to 156 nodes and 15 to 21 hops in diameter (cases 1013, 1086, and 1095 have 1,898, 2,008, and 1,913 nodes). Airfoil uses a 5,233-node mesh (Nℓ=407N_\ell=407, diameter 19). GLaDiT conditions directly on mesh coordinates, connectivity, and boundaries; cross-shape pretraining remains future work (Section 7).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.