acceptodds
Under review as a conference paper at ICLR 2027

AMR-VNO: A Native-Leaf Surrogate for Block-Structured Adaptive Meshes

Abstract

Adaptive mesh refinement (AMR) solvers store solutions on nested levels of cells, yet most grid-based neural operators first rasterize these fields onto a uniform grid. We introduce AMR-VNO (AMR V-cycle Neural Operator), whose computational graph is the solver's block-AMR hierarchy, extended where needed by virtual coarse levels built from the inputs. It exchanges direction-aware messages within each level, moves information between levels through learned restriction and prolongation shared across levels, and predicts directly on active leaf cells. On the evaluated held-out 2D Darcy and advection-diffusion sets, AMR-VNO has 14 to 20% lower mean error against the solver's discrete targets than a tuned multigrid neural operator, with about 34 times fewer learned parameters, and lower error than graph and sparse-convolution models given the same hierarchy. It also improves over same-hierarchy message passing on in-distribution 3D conduction. On public Quokka turbulence, AMR-VNO and hierarchy message passing both outperform dense baselines but are not statistically distinguishable. In Darcy validation ablations, direction-aware aggregation and a second traversal each reduce error. Accuracy degrades on deeper hierarchies and changed refinement policies, so sharing weights across levels does not by itself give transfer across hierarchy structure.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
neural operators, adaptive mesh refinement, scientific machine learning

Reviews

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

This paper proposes AMR-VNO, a neural operator that works directly on block-structured adaptive mesh refinement (AMR) hierarchies. The method uses direction-aware message passing, learned restriction/prolongation, and shared-weight V-cycle processing to predict PDE solutions on active leaf cells. The authors test the method on four PDE benchmarks and report better accuracy than several baselines, especially for the 2D problems. However, the results are less convincing on some 3D tests, and the method shows clear limitations when generalizing to different refinement depths and policies.

Critical strengths
  1. The paper considers a useful and practical problem. Working directly on AMR hierarchies avoids the need to convert adaptive meshes into uniform grids and allows information exchange across different resolution levels.

  2. The paper provides a reasonably broad set of experiments, including comparisons with several neural operator and graph-based methods. The ablation studies and additional tests are also helpful for understanding the performance and limitations of the proposed method.

Critical weaknesses

My main concern is that the proposed method seems to be largely built on existing ideas, such as hierarchical message passing, learned restriction/prolongation, multigrid V-cycles, and weight sharing across levels. These are already quite common in multiscale GNNs and multigrid-based neural operators (e.g., MgNO, multiscale MeshGraphNets, and adaptive-mesh GNNs). As I understand it, the main difference is that the authors apply these techniques directly to solver-generated AMR hierarchies. While this is a reasonable design choice, I am not fully convinced that it brings enough new methodological contributions compared with existing works. The paper could better explain what is really new about the proposed architecture and why it should work better than other hierarchical methods. Also, most of the key ablation studies are carried out only on Darcy, so it is not clear whether the same findings hold for other problems.

Another concern is that the experiments do not sufficiently show how well the method can work in more general AMR settings. Most of the test problems use static, input-derived mesh hierarchies. Even for Quokka, the model predicts on the current mesh without considering how the mesh may change in the future. There are no long-term rollout tests with dynamic regridding, which I think would be important for showing the usefulness of the method in realistic AMR simulations.

I am particularly concerned about the generalization results. The method performs significantly worse when just one additional refinement level is introduced, and it even becomes less accurate than the hierarchy MPNN in this case. Changing the refinement policy also leads to worse results. This suggests that the method still depends quite strongly on the mesh hierarchy used during training, despite sharing weights across levels. I think this is an important limitation for a method specifically designed for adaptive meshes.

The reported accuracy and efficiency improvements are also somewhat mixed. On Quokka, AMR-VNO performs almost the same as the hierarchy MPNN. On Darcy, its advantage becomes quite small when compared against a finer numerical reference. Also, having fewer parameters does not necessarily make the method faster or more memory-efficient, as shown by some of the runtime and memory results. The different tuning budgets and the way the benchmarks were selected also make it harder to draw strong conclusions from the comparisons.

Overall, I think the idea of working directly on AMR hierarchies has some practical value, but I am not fully convinced by the methodological novelty or the generalization and efficiency advantages demonstrated in the current paper.

Questions for authors
  1. What are the main methodological differences between AMR-VNO and existing multigrid-based neural operators or hierarchical GNNs, apart from using solver-generated AMR hierarchies? Could the authors explain more clearly what is new in the proposed method?

  2. Why does the method show such a large performance drop when tested with one additional refinement level or a different refinement policy, even though the weights are shared across levels? Would training on more varied mesh hierarchies help address this issue?

  3. How would the method handle long-term autoregressive prediction when the mesh hierarchy changes over time? It would be useful to see experiments with actual dynamic regridding, rather than predicting only on the current mesh.

  4. Could the authors provide more balanced baseline comparisons in terms of training budget, tuning effort, and computational cost?

  5. Could the authors include MgNO-48, rather than only MgNO-24, in the Darcy fine-reference comparison? More generally, in what situations does AMR-VNO offer clear advantages in terms of prediction accuracy, runtime, and memory usage over existing methods?

4 comments

Thank you for the detailed review. We quote each point and answer it below. A revised PDF is uploaded; it adds the new results to the main text (Sections 4, 6.1, 6.3, Limitations) and a new Appendix C.

My main concern is that the proposed method seems to be largely built on existing ideas, such as hierarchical message passing, learned restriction/prolongation, multigrid V-cycles, and weight sharing across levels.

What are the main methodological differences between AMR-VNO and existing multigrid-based neural operators or hierarchical GNNs, apart from using solver-generated AMR hierarchies? Could the authors explain more clearly what is new in the proposed method?

We agree the components are known individually. What the solver's block-AMR hierarchy forces in the architecture:

  • covered (refined) parent cells stay as nodes, so every level carries state and the V-cycle restricts and prolongs between existing solver levels rather than constructed pools;
  • where used (not on Quokka), virtual coarse levels are built from the inputs below the solver's coarsest level, so the cycle reaches the whole domain;
  • messages are per face direction within each level; because covered parents are kept, a coarse-fine interface is crossed through the parent-child links (learned restriction and prolongation) rather than through interpolated cross-level edges;
  • predictions are made only on active leaf cells, the solver's own output locations.

Levels and outputs, as the cited papers describe them:

MethodWhere the levels come fromOutput
MgNO (He et al., ICLR 2024)multigrid-structured operators on a uniform griduniform grid
MultiScale MeshGraphNets (Fortunato et al., 2022)two resolutions (fine and coarse)mesh nodes
BSMS-GNN (Cao et al., ICML 2023)bi-stride pooling of the input mesh, interpolation-based unpoolingmesh nodes
Graph U-Nets (Gao and Ji, 2019)learned pooling scoresgraph nodes
Perera and Agrawal (CMAME 2024)all levels of a block-structured AMR mesh (vertices as nodes); multigrid-like down- and up-samplingnext-step mesh field
AMR-Transformer (Xu et al., CVPR 2025)input-derived multiresolution tokens from dense fields, global attentiondense field
AMR-VNOthe solver's block-AMR levels, covered parents kept (plus virtual coarse levels where used)active leaf cells

The closest prior work is Perera and Agrawal, who also mimic a multigrid solver over all levels of a block-structured AMR mesh, for next-step phase-field fracture. Their graph nodes are mesh vertices, and downsampling removes the finest refinement levels; AMR-VNO's nodes are cells, it keeps covered parents and predicts on active leaf cells. We have not run their model.

The paper could better explain what is really new about the proposed architecture and why it should work better than other hierarchical methods.

Evidence that the processor and these choices matter: on the same cells and links, the paper's 32-step hierarchy MPNN has about 2.9 and 1.9 times AMR-VNO's held-out error on Darcy and HeatTransport2D, and a hierarchy graph U-Net about 2.8 and 2.9 times. In separately trained seed-0 Darcy variants of a position-aware model, removing the virtual coarse levels raises validation error from 0.0023 to 0.12. Direction-aware messages lower validation error on Darcy and on Conduction3D (next point). The revision adds Algorithm 1 with the full forward pass.

Also, most of the key ablation studies are carried out only on Darcy, so it is not clear whether the same findings hold for other problems.

During the discussion we ran the direction x cycles ablation on Conduction3D (the paper's 50-epoch recipe, three seeds per cell, 100 validation cases, paired case bootstrap; revised Appendix C.2):

1 cycle2 cycles
Isotropic messages0.02150.0204
Directional messages0.01660.0157

Directional messages lower error by 0.0049 at one cycle (95% interval [0.0040, 0.0058]) and 0.0047 at two ([0.0039, 0.0054]); a second cycle lowers it by 0.0011 isotropic ([0.0006, 0.0017]) and 0.0009 directional ([0.0005, 0.0013]); the interaction interval includes zero. So both Darcy findings hold on Conduction3D.

I am particularly concerned about the generalization results. The method performs significantly worse when just one additional refinement level is introduced, and it even becomes less accurate than the hierarchy MPNN in this case.

Why does the method show such a large performance drop when tested with one additional refinement level or a different refinement policy, even though the weights are shared across levels? Would training on more varied mesh hierarchies help address this issue?

Training on more varied hierarchies helps but does not fix it. During the discussion we generated 60 fresh maximum-level-6 Conduction3D cases (three families, one never used in training) and scored every fixed checkpoint once, under a plan and result wording frozen before scoring (three seeds per arm; revised Section 6.3 and Appendix C.2):

Training dataAMR-VNOHierarchy MPNN
Level 5 only (paper models)0.03340.0245
Levels 4 + 5 (level 6 unseen)0.02080.0160
Levels 5 + 6 (level 6 seen)0.01310.0151
  • Trained on levels 4 and 5, AMR-VNO's error at the unseen level 6 falls by 0.0126 ([0.0111, 0.0141]), but the MPNN trained the same way is still better (difference 0.0049, [0.0031, 0.0068]; AMR-VNO lower on 27% of cases; MPNN better on all three families).
  • With level-6 data, AMR-VNO beats the MPNN trained the same way (difference 0.0020, [0.0012, 0.0027]; lower on 78% of cases), but that is training on the target depth, not transfer.

Why: weight sharing fixes the parameter count, not the function at a new depth. The fixed Darcy model depends strongly on its trained hierarchy: removing virtual coarse levels at inference raises validation error from 0.0022 (nine levels) to 0.16 (five; Appendix B.4, Table 25). For a changed refinement policy, most of the Darcy error comes from the coarser output space: the leaf-constant floor alone (0.00905) is 87% of AMR-VNO's squared error and 89% of that of an MgNO-24 projected to the same leaves. Within that space AMR-VNO is still worse (0.00344 vs 0.00305), and policy-mixture training did not recover the ranking (Appendix B.4). We agree this is an important limitation for an adaptive-mesh method; Section 6.3 gives these numbers, and the revised abstract and Limitations state the limitation.

There are no long-term rollout tests with dynamic regridding, which I think would be important for showing the usefulness of the method in realistic AMR simulations.

How would the method handle long-term autoregressive prediction when the mesh hierarchy changes over time? It would be useful to see experiments with actual dynamic regridding, rather than predicting only on the current mesh.

Thank you for pushing on this; we have now run that experiment (revised PDF, Appendix C.3, Table 29). On Quokka, AMR-VNO and the hierarchy MPNN were trained to predict all four conserved fields one step ahead (same 65-minute GPU budget, three seeds), then rolled out 11 steps on their own predictions from frame 2. After every step the hierarchy is rebuilt from the predicted density with a gradient-threshold rule calibrated against the solver's meshes, and fields are transferred conservatively. On 16 held-out trajectories, step-11 density error is 0.0830 for AMR-VNO, 0.0864 for the MPNN and 0.1478 for persistence (4.1% lower than the MPNN, [3.1, 5.0]; lower on all 16); momentum is 1.0% lower ([0.5, 1.5]; 14 of 16); mass drift is 0.12% vs 0.24%. All 96 rollouts stayed finite. The comparison is at equal training time (the MPNN needs activation checkpointing and completed fewer updates), and the tagging rule, not the model, decides where to refine.

Could the authors provide more balanced baseline comparisons in terms of training budget, tuning effort, and computational cost?

Tuning. During the discussion we re-searched MgNO and the hierarchy MPNN under one written procedure, with AMR-VNO not retuned (revised Section 6.1 and Appendix C.1): full-length 500-epoch trials, selection by seed-0 validation error after reloading the saved checkpoint, two further seeds for a new winner, and trial counts reported (including diverged runs). About 104, 165 and 151 training hours plus 67 and 79 for extra seeds, the same order as AMR-VNO's 160.8 retained Darcy hours. The search kept MgNO-48 on Darcy and found stronger HeatTransport2D MgNO (64 channels, 4.61M parameters) and Darcy MPNN models. We then scored all 21 fixed checkpoints (three seeds each) once on a newly generated held-out set (200 Darcy, 100 HeatTransport2D cases), with the result sentences frozen first:

ContrastAMR-VNOBaselineAMR-VNO lower on
Darcy, MgNO-480.0021340.00268173% of cases
Darcy, searched MPNN0.0021340.005506100%
HeatTransport2D, searched MgNO0.0019900.00225739%

All three 95% paired case-bootstrap intervals exclude zero, but the HeatTransport2D advantage is narrow: on a typical case the searched MgNO, 61 times AMR-VNO's size, is slightly better. FNO, U-Net, CNO, GINO and the sparse U-Net were not re-searched; their numbers stand with that caveat.

Compute. No FLOP-matched runs. Matched in parameters, an 8-channel MgNO (73,504 parameters), rerun under the search protocol, reaches 0.00402 Darcy validation error at seed 0 against AMR-VNO's 0.00223 at seed 0.

On Quokka, AMR-VNO performs almost the same as the hierarchy MPNN. On Darcy, its advantage becomes quite small when compared against a finer numerical reference.

Could the authors include MgNO-48, rather than only MgNO-24, in the Darcy fine-reference comparison?

Yes, and the result goes against us. On 100 validation cases (three seeds per model, paired case bootstrap), against the fine reference MgNO-48 reaches 0.014230 and AMR-VNO 0.014295 relative L2. The 95% interval of MgNO-48 minus AMR-VNO is [-0.000109, -0.000020], and AMR-VNO is lower on only 35% of cases, so MgNO-48 is slightly but significantly more accurate there. The packaged Darcy target itself differs from the reference by 0.0141, so our Darcy headline measures emulation of the solver's discrete output, not fidelity to the PDE. The revised PDF adds MgNO-48 to the fine-reference table (Table 5) and states this in the abstract, Section 6.3 and Limitations. On Quokka we agree: AMR-VNO and the hierarchy MPNN are not distinguishable. Quokka's octree has only two levels, so there is little hierarchy for the V-cycle to use.

Also, having fewer parameters does not necessarily make the method faster or more memory-efficient, as shown by some of the runtime and memory results.

More generally, in what situations does AMR-VNO offer clear advantages in terms of prediction accuracy, runtime, and memory usage over existing methods?

  • Accuracy: lower held-out mean error against the solver's discrete targets than every evaluated baseline on the two 2D benchmarks, including the searched ones on the second held-out set (narrowly on HeatTransport2D, lower on only 39% of cases), at about 1/34 of MgNO-48's parameters. On in-distribution Conduction3D the same-hierarchy MPNN has about 24% higher error. Not more accurate than MgNO-48 against the Darcy fine reference; not distinguishable from the MPNN on Quokka.
  • Runtime and memory (now in the main text, Section 6.3): no advantage on Darcy (1.49 times the CPU solver's time; 81.0 vs 30.5 ms and 156.5 vs 56.0 MiB against MgNO-48 at batch one). On HeatTransport2D it is faster than the solver (0.12 times) and than MgNO-48 (99.8 vs 142.2 ms), but uses more memory (394 vs 225 MiB). In a computation-only 3D sweep at 256^3 it had the lowest latency and memory of four models when refinement covers a small part of the domain; dense models are faster at lower maximum levels.
  • Transfer and rollout: none across depth or refinement policy. In an 11-step Quokka rollout with regridding after every step, AMR-VNO has lower error than the MPNN (Appendix C.3).

We agree with your overall assessment that the practical value is in working directly on AMR hierarchies; the revision states the accuracy, efficiency and generalization limits as plainly as the gains.

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

The paper proposes a new neural operator for solving PDEs with neural networks. INstead of a uniform grid they propose to use two levels of hierachy (coarse and fine) levels that can adapt the amount of computation dependend on the dynamics.

Critical strengths

Combining message passing with adaptive computational grid is interesting The method appears to be very parameter-efficient

Critical weaknesses

the paper is very badly written and hard to understand the experiments are only single-step predictions and not multi-step AR rollouts, limiting application and impact the model is slower than comparisons and the original CPU solver, weakining any motivation to actually use this neural operator relatively low gains from the method the proposed method is significantly more tuned than baselines or comparison methods (Tab8 in appendix: 160h vs e.g. 9h for FNO).

Questions for authors

why does performance degrade when evaluating on deeper hierachy levels? what are the results of compute matched baselines on the datasets evaluated?

3 comments

Thank you for the review. We quote each point and answer it below. A revised PDF is uploaded; it adds the new results to the main text (Sections 4, 6.1, 6.3, Limitations) and a new Appendix C.

INstead of a uniform grid they propose to use two levels of hierachy (coarse and fine) levels that can adapt the amount of computation dependend on the dynamics.

AMR-VNO runs on the solver's full hierarchy, not two levels. On Darcy it uses nine levels: three native AMR levels plus six virtual coarse levels built from the inputs. On HeatTransport2D it uses three native plus seven virtual levels, and on Conduction3D native octree levels 2 to 5 plus two virtual coarse levels down to the root. The exception is Quokka, whose octree has two levels; that is also where AMR-VNO and the hierarchy MPNN are not distinguishable. The revised PDF makes this explicit in the introduction, the Figure 1 caption and Section 4.

the paper is very badly written and hard to understand

We are sorry the paper was hard to follow. The revision adds Algorithm 1 (Appendix A.9, referenced from Section 4), which gives the forward pass step by step (encode every cell; two down-and-up sweeps over all levels with direction-aware smoothing, learned restriction and prolongation; decode on active leaf cells only), states the level structure of every benchmark in Section 4 and the Figure 1 caption, and puts the new results and their limits in Sections 6.1 and 6.3, Limitations and Appendix C.

the proposed method is significantly more tuned than baselines or comparison methods (Tab8 in appendix: 160h vs e.g. 9h for FNO).

You are right that the original tuning was unequal. During the discussion we re-searched the two closest competitors, MgNO and the hierarchy MPNN, under one written procedure, with AMR-VNO not retuned (revised Section 6.1 and Appendix C.1): full-length 500-epoch trials, selection by seed-0 validation error after reloading the saved checkpoint, two further seeds for a new winner, and trial counts reported, including diverged runs. The search took about 104 training hours for Darcy MgNO, 165 for HeatTransport2D MgNO and 151 for the MPNN, plus 67 and 79 for the extra seeds of the two new winners: the same order as AMR-VNO's 160.8 retained Darcy hours, though elapsed hours are not a matched compute budget.

Family (benchmark)Selected3-seed validationAMR-VNO
MgNO (Darcy)MgNO-48, unchanged0.0021120.002096
MgNO (HeatTransport2D)64 channels, 4.61M parameters0.002321 (paper's: 0.002500)0.002019
Hierarchy MPNN (Darcy)32 steps, hidden 960.005133 (paper's: 0.005960)0.002096

The search made two baselines stronger. We then generated a second held-out set with the paper's solvers (200 Darcy, 100 HeatTransport2D cases), froze the protocol and result sentences, and scored all 21 fixed checkpoints (three seeds each) exactly once:

ContrastAMR-VNOBaselineAMR-VNO lower on
Darcy, MgNO-480.0021340.00268173% of cases
Darcy, searched MPNN0.0021340.005506100%
HeatTransport2D, searched MgNO0.0019900.00225739%

All three 95% paired case-bootstrap intervals exclude zero, but the HeatTransport2D advantage is narrow: on a typical case the searched MgNO (61 times AMR-VNO's size) is slightly better. FNO, your example, was not re-searched; its 9-hour result stands with that caveat, and we make no claim against a tuned FNO.

what are the results of compute matched baselines on the datasets evaluated?

We have no FLOP-matched runs. Matched in parameters, an 8-channel MgNO (73,504 parameters, against AMR-VNO's 75,265), rerun under the search protocol, reaches 0.00402 Darcy validation error at seed 0 against AMR-VNO's 0.00223 at seed 0. Matched in tuning procedure, the searched baselines and the second held-out result are in our previous comment; those baselines are larger than AMR-VNO (MgNO 34 to 61 times; the MPNN has 101,857 parameters).

relatively low gains from the method

We agree the gains are modest. On the paper's held-out set AMR-VNO's mean error is 20% below MgNO-48 on Darcy (lower on 76.5% of cases) and 14% below on HeatTransport2D (lower on 54%). On the second held-out set it is 20% below MgNO-48 on Darcy and 12% below the searched MgNO on HeatTransport2D, but lower on only 39% of HeatTransport2D cases. Against a finer Darcy reference the gain reverses: MgNO-48 is slightly but significantly more accurate (0.014230 vs 0.014295; revised Table 5). Fewer parameters alone is not a reason to use AMR-VNO; the case for it is that it runs on the solver's own hierarchy and predicts on the solver's own output cells.

the model is slower than comparisons and the original CPU solver, weakining any motivation to actually use this neural operator

Correct on Darcy: it takes 1.49 times the CPU solver's time and is slower than MgNO-48 (81.0 vs 30.5 ms at batch one). On HeatTransport2D it is faster than the solver (0.12 times, one deployment) and than MgNO-48 (99.8 vs 142.2 ms at batch one), though it uses more memory. In a computation-only Conduction3D sweep at 256^3 (no accuracy claim) it had the lowest latency and memory of four models (224 ms and 2.60 GiB; FNO 389 ms and 9.69 GiB; U-Net 551 ms and 5.86 GiB; hierarchy MPNN 2,117 ms and 4.89 GiB); dense models are faster at lower maximum levels. The revised PDF now states these cost numbers in Section 6.3. The use case is therefore large domains with sparse refinement, not small 2D problems.

the experiments are only single-step predictions and not multi-step AR rollouts, limiting application and impact

We have now added an autoregressive rollout (revised PDF, Appendix C.3, Table 29). On Quokka 3D turbulence, AMR-VNO and the hierarchy MPNN were each trained to predict density and the three momenta one step ahead (same 65-minute GPU budget, three seeds), then rolled out 11 steps on their own predictions from frame 2. After every step the AMR hierarchy is rebuilt from the predicted density and the fields are transferred conservatively, so the mesh changes during the rollout. Relative L2 on 16 held-out trajectories:

FieldStepAMR-VNOHierarchy MPNNPersistenceAMR-VNO vs MPNN
Density10.00410.00440.01326.0% [4.4, 8.6]
Density110.08300.08640.14784.1% [3.1, 5.0]
Momentum110.36640.37010.59521.0% [0.5, 1.5]

All rollouts stayed finite. At step 11 AMR-VNO is lower on density for all 16 trajectories and on momentum for 14, with half the MPNN's mass drift (0.12% vs 0.24%). This is an 11-step horizon on one benchmark at equal training time; we do not claim long-horizon stability.

why does performance degrade when evaluating on deeper hierachy levels?

We do not have a confirmed answer. Weight sharing fixes the parameter count, not the function the network computes at a new depth. The fixed Darcy model depends strongly on the hierarchy it was trained on: removing virtual coarse levels at inference raises its validation error from 0.0022 (nine levels) to 0.017 with eight and 0.16 with five (Appendix B.4, Table 25), and the learned cycle is not contractive.

During the discussion we ran a new depth test on 60 fresh maximum-level-6 Conduction3D cases, scoring every fixed checkpoint once under a plan frozen before scoring (three seeds per arm; revised Section 6.3 and Appendix C.2):

Training dataAMR-VNOHierarchy MPNN
Level 5 only (paper models)0.03340.0245
Levels 4 + 5 (level 6 unseen)0.02080.0160
Levels 5 + 6 (level 6 seen)0.01310.0151

Training on two depths lowers AMR-VNO's error at the unseen depth, but the MPNN trained the same way is still better there (AMR-VNO lower on only 27% of cases). With level-6 data in training AMR-VNO is better than the MPNN (lower on 78% of cases), but that is not transfer. We therefore claim no depth or policy robustness; Section 6.3 gives these numbers, and the abstract and Limitations state the limitation.

In short. Helps: lower held-out mean error than the paper's and the searched baselines on the two 2D benchmarks (narrowly on HeatTransport2D), at about 1/34 of MgNO-48's parameters; HeatTransport2D latency; latency and memory when 3D refinement is sparse; lower error than the MPNN in an 11-step Quokka rollout with regridding. Does not: Darcy speed and memory; HeatTransport2D memory; Darcy fine-reference accuracy against MgNO-48; depth or policy transfer.

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

This paper presents a neural operator designed to process adaptive mesh refinement (AMR) hierarchies directly, referred as AMR-VNO, eliminating the need to interpolate data onto uniform grids. Utilizing a V-cycle architecture for multi-level feature transfer, the model predicts solutions on active leaf cells. Across four benchmark tests, AMR-VNO achieves lower error rates than several baseline models on 2D problems while requiring significantly fewer parameters. However, its accuracy tends to decline with deeper mesh hierarchies or under shifting refinement policies.

Critical strengths

By operating directly on the mesh hierarchy, the proposed method eliminates the need to “rasterize” data onto a uniform grid. The authors evaluate their approach against multiple baselines, including models that leverage the same hierarchical structure. Additionally, ablation studies are conducted to analyze the individual contributions of key architectural components. To ensure reproducibility, the paper provides several benchmark datasets alongside publicly available code.

Critical weaknesses

While promising, the evaluation covers a limited range of PDE settings, so the model's performance on more complex problems remains unclear. The model also does not generalize consistently to deeper hierarchies or different refinement policies. In addition, the baseline comparisons are not fully controlled for model size, optimization, and computational budget. Finally, the efficiency gains still depend on the problem, a discussion remains on efficiency and memory compared to other methods.

Questions for authors

How well does AMR-VNO generalize to refinement/hierarchy depths that differ from those seen during training? Could the authors compare AMR-VNO with stronger neural-operator baselines using more closely matched training settings and compute budgets? Do the reported accuracy gains remain when predictions are evaluated against a finer reference solution rather than the solver's discrete targets? How could AMR-VNO be extended to transient problems in particular if the mesh hierarchy changes during the rollout? Finally, in which problem settings does AMR-VNO provide a clear runtime or memory advantage over existing methods?

4 comments

Thank you for the careful review. We quote each point and answer it below. A revised PDF is uploaded; it adds the new results to the main text (Sections 4, 6.1, 6.3, Limitations) and a new Appendix C.

The model also does not generalize consistently to deeper hierarchies or different refinement policies.

How well does AMR-VNO generalize to refinement/hierarchy depths that differ from those seen during training?

Not reliably, and the abstract says so. Without retraining, one level deeper on Conduction3D the hierarchy MPNN has lower error than AMR-VNO (0.0279 vs 0.0353). During the discussion we ran a new test to see whether training on more than one depth fixes this.

New depth test (post hoc; revised Section 6.3 and Appendix C.2). We generated 60 fresh maximum-level-6 Conduction3D cases (three geometry families, one never used in training) and scored every fixed checkpoint once, with the plan and result wording frozen before scoring. Three seeds per arm; seed-averaged volume-weighted relative L2; paired case bootstrap intervals.

Training dataAMR-VNOHierarchy MPNN
Level 5 only (paper models)0.03340.0245
Levels 4 + 5 (level 6 unseen)0.02080.0160
Levels 5 + 6 (level 6 seen)0.01310.0151
  • Trained on levels 4 and 5, AMR-VNO's error at the unseen level 6 falls by 0.0126 (95% interval [0.0111, 0.0141]), but the MPNN trained the same way is still better: difference 0.0049 ([0.0031, 0.0068]), AMR-VNO lower on only 27% of cases, and the MPNN is better on all three families.
  • With level-6 data in training, AMR-VNO beats the MPNN trained the same way (0.0131 vs 0.0151; difference 0.0020, [0.0012, 0.0027]; lower on 78% of cases). That is training on the target depth, not transfer.
  • The retrained models used 1.5x the paper's steps and 400 extra cases; they do not replace the paper's models.

So depth transfer remains a limitation. Section 6.3 gives these numbers; the abstract and Limitations state the limitation.

One reason is visible in the paper: the fixed Darcy model depends strongly on the hierarchy it was trained on. Removing virtual coarse levels at inference raises its validation error from 0.0022 (nine levels) to 0.017 with eight and 0.16 with five (Appendix B.4, Table 25), and the learned cycle is not contractive, so more cycles are not guaranteed to help.

For a changed refinement policy, most of the Darcy error comes from the coarser output space: the leaf-constant floor alone (0.00905) is 87% of AMR-VNO's squared error and 89% of that of an MgNO-24 projected to the same leaves. Within that space AMR-VNO is still worse (0.00344 vs 0.00305, validation), and policy-mixture training did not recover the ranking (Appendix B.4). We claim no depth or policy robustness.

In addition, the baseline comparisons are not fully controlled for model size, optimization, and computational budget.

Could the authors compare AMR-VNO with stronger neural-operator baselines using more closely matched training settings and compute budgets?

We agree the original tuning was unequal (Table 8: AMR-VNO at least 160.8 Darcy development hours, FNO about 9). During the discussion we re-searched the two closest competitors under one written procedure, with AMR-VNO not retuned (revised Section 6.1 and Appendix C.1).

Search procedure. Full-length 500-epoch trials (no early stopping of trials); selection by seed-0 validation error after reloading the saved checkpoint; two further seeds for a new winner; trial counts, including diverged runs, are reported. The search used about 104, 165 and 151 training hours, plus 67 and 79 for the extra seeds: the same order as AMR-VNO's development hours, though elapsed hours are not a matched compute budget.

Family (benchmark)New trialsSelected3-seed validationAMR-VNO
MgNO (Darcy)12 + retained 9-point gridMgNO-48, unchanged0.0021120.002096
MgNO (HeatTransport2D)664 channels, 4.61M parameters0.002321 (paper's: 0.002500)0.002019
Hierarchy MPNN (Darcy)432 steps, hidden 960.005133 (paper's: 0.005960)0.002096

The search found stronger HeatTransport2D MgNO and MPNN models; both are larger than the paper's.

Second held-out set, scored once. We generated new held-out cases with the paper's solvers (200 Darcy, 100 HeatTransport2D) after freezing the protocol and the result sentences, and scored all 21 fixed checkpoints (three seeds each) exactly once. Relative L2 against the solver's discrete targets; paired case bootstrap.

ContrastAMR-VNOBaseline95% interval (baseline minus AMR-VNO)AMR-VNO lower on
Darcy, MgNO-480.0021340.002681[0.00041, 0.00069]73% of cases
Darcy, searched MPNN0.0021340.005506[0.00314, 0.00361]100%
HeatTransport2D, searched 64-channel MgNO0.0019900.002257[0.00003, 0.00055]39%

AMR-VNO keeps the lower mean error in all three contrasts, but the HeatTransport2D advantage is narrow: on a typical case the searched MgNO, 61 times AMR-VNO's size, is slightly better, and the mean gap comes from a minority of cases. The revised PDF states it this way.

Size and compute. We have no FLOP-matched runs. Matched in parameters, an 8-channel MgNO (73,504 parameters, against AMR-VNO's 75,265), rerun under the search protocol at learning rate 2e-3, reaches 0.00402 Darcy validation error at seed 0 against AMR-VNO's 0.00223 at seed 0 (Table 13's 0.0104 used the original recipe). FNO, U-Net, CNO, GINO and the sparse U-Net were not re-searched for compute reasons; their numbers stand with that caveat.

Do the reported accuracy gains remain when predictions are evaluated against a finer reference solution rather than the solver's discrete targets?

Partly; it depends on the benchmark (revised Table 5 and Section 6.3).

  • Darcy: no. We added MgNO-48 to the fine-reference comparison (100 validation cases, three seeds per model, paired case bootstrap). Against the fine reference MgNO-48 reaches 0.014230 and AMR-VNO 0.014295; the 95% interval of MgNO-48 minus AMR-VNO is [-0.000109, -0.000020], and AMR-VNO is lower on only 35% of cases. So MgNO-48 is slightly but significantly more accurate there. The packaged Darcy target itself is 0.0141 from that reference, so our Darcy headline measures emulation of the solver's discrete output, not fidelity to the PDE. The revised abstract, Section 6.3 and Limitations say this.
  • HeatTransport2D: yes. The packaged target is 0.00042 from an independent 1024^2 solution, against model errors near 0.002, and AMR-VNO stays ahead of MgNO-48 (per-case gap +0.00052, 95% t-interval [0.00020, 0.00083], lower on 82% of cases). Against the searched 64-channel MgNO the gap is +0.00034 ([0.00002, 0.00065]), but AMR-VNO is lower on only 52% of cases, and that MgNO was selected on these same 50 cases.
  • Conduction3D (validation, uniform level-5 reference): AMR-VNO 0.0183, hierarchy MPNN 0.0200, FNO 0.0231.

How could AMR-VNO be extended to transient problems in particular if the mesh hierarchy changes during the rollout?

We have tested this (revised PDF, Appendix C.3, Table 29). On Quokka, AMR-VNO predicts density and momentum one step ahead and rolls out 11 steps on its own predictions. After every step the hierarchy is rebuilt from the predicted density with a gradient-threshold tagging rule calibrated against the solver's meshes, and fields are moved to it conservatively. Because the weights are shared across hierarchies, the same network runs on each new mesh. Over 16 held-out trajectories (three seeds), density relative L2 after 11 steps is 0.0830 for AMR-VNO, 0.0864 for the hierarchy MPNN trained the same way, and 0.1478 for persistence. That is 4.1% [3.1, 5.0] lower than the MPNN, and lower on all 16 trajectories. All rollouts stayed finite. The tagging rule, not the network, decides where to refine.

Finally, the efficiency gains still depend on the problem, a discussion remains on efficiency and memory compared to other methods.

Finally, in which problem settings does AMR-VNO provide a clear runtime or memory advantage over existing methods?

Only in some settings, and the revised Section 6.3 now states the numbers in the main text:

  • End to end against the solver: AMR-VNO takes 1.49 times the CPU solver's time on Darcy (slower) and 0.12 times on HeatTransport2D (faster; one deployment).
  • Against MgNO-48 at batch one: on Darcy AMR-VNO is slower (81.0 vs 30.5 ms) and uses more transient memory (156.5 vs 56.0 MiB); on HeatTransport2D it is faster (99.8 vs 142.2 ms) but uses more memory (394 vs 225 MiB). At batch eight on HeatTransport2D AMR-VNO is still faster than MgNO-48 (36.7 vs 45.1 ms per sample), but the sparse U-Net becomes fastest (30.2 ms).
  • Quokka: lower latency than a 4-step hierarchy MPNN of similar accuracy (17.7 vs 28.4 ms).
  • 3D, sparse refinement: in a computation-only Conduction3D sweep at 256^3 (no accuracy claim) it had the lowest latency and memory of four models (224 ms and 2.60 GiB; FNO 389 ms and 9.69 GiB; U-Net 551 ms and 5.86 GiB; hierarchy MPNN 2,117 ms and 4.89 GiB). The advantage is largest when refinement covers a small part of the domain; at the largest refined fraction its memory exceeds U-Net's, and at lower maximum levels dense models are faster.

So the clear runtime and memory case is large 3D domains with sparse refinement; on small 2D problems it is not faster or leaner than MgNO-48.

While promising, the evaluation covers a limited range of PDE settings, so the model's performance on more complex problems remains unclear.

Agreed: four benchmarks is narrow, and the revised Limitations say so. They cover a 2D elliptic problem (Darcy), 2D advection-diffusion (HeatTransport2D), 3D conduction on octrees (Conduction3D) and public 3D turbulence data (Quokka), where we now also run an 11-step rollout with regridding (Appendix C.3); harder settings and longer horizons remain future work.

In short. Helps: lower held-out mean error against the solver's discrete targets on the two 2D benchmarks, against both the paper's and the searched baselines (narrowly on HeatTransport2D), at about 1/34 of MgNO-48's parameters; HeatTransport2D latency at batch one; latency and memory when 3D refinement is sparse; lower error than the MPNN in an 11-step Quokka rollout with regridding. Does not: Darcy fine-reference accuracy against MgNO-48; Darcy runtime and memory; HeatTransport2D memory; transfer across depth or refinement policy.

Comments on the paper

1 comment

We thank the three reviewers. Their main shared concerns were unequal baseline tuning, possible overfitting to one held-out set, ablations on Darcy only, single-step evaluation without regridding, clarity of the method, and the scope of the claims. The revised PDF is uploaded. Here is what changed; the per-reviewer replies give details.

1. Baselines re-searched under one written procedure (Section 6.1, Appendix C.1). The two closest competitors, MgNO and the hierarchy MPNN, were re-searched with full-length 500-epoch trials and seed-0 checkpoint selection. AMR-VNO was not retuned. The search found HeatTransport2D MgNO (64 channels, 4.61M parameters) and Darcy MPNN models that are stronger than the paper's versions, and the comparisons below use them.

2. A second held-out set, generated and scored once. We generated new cases with the paper's solvers (200 Darcy, 100 HeatTransport2D), froze the protocol and the result sentences, then scored all 21 fixed checkpoints once. AMR-VNO keeps the lower mean error in every contrast:

ContrastAMR-VNOBaseline95% interval (baseline minus AMR-VNO)
Darcy, MgNO-480.0021340.002681[0.00041, 0.00069]
Darcy, searched MPNN0.0021340.005506[0.00314, 0.00361]
HeatTransport2D, searched 64-channel MgNO0.0019900.002257[0.00003, 0.00055]

On Darcy, AMR-VNO has about 1/34 of MgNO-48's parameters.

3. Ablation now also on 3D (Appendix C.2). On Conduction3D, a direction x cycles ablation with three seeds per cell shows that directional messages lower error by 0.0049 at one cycle (95% interval [0.0040, 0.0058]) and 0.0047 at two ([0.0039, 0.0054]). A second cycle also helps.

4. Clarity (Section 4, Figure 1, Appendix A.9). We added Algorithm 1 for the forward pass and made the level structure of every benchmark explicit. For example, Darcy uses nine levels (three native plus six virtual), so the method runs on the full hierarchy, not on two levels.

5. Autoregressive rollout with dynamic regridding (Appendix C.3, Table 29). On Quokka, AMR-VNO and the hierarchy MPNN (same 65-minute GPU budget, three seeds) roll out 11 steps on their own predictions, with the AMR hierarchy rebuilt from the predicted density after every step. On 16 held-out trajectories, AMR-VNO's step-11 density error is 0.0830 against 0.0864 for the MPNN and 0.1478 for persistence (4.1% lower, 95% interval [3.1, 5.0]; lower on all 16 trajectories), and its total-mass drift is 0.12% against 0.24%.

6. Claims matched to the evidence (abstract, Section 6.3, Limitations). We added runtime and memory to the main text and stated the depth and refinement-policy dependence with numbers. The revision says where AMR-VNO helps (accuracy on solver-native AMR targets at small parameter count; latency and memory in sparse 3D refinement) and where it does not.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.