acceptodds
Under review as a conference paper at ICLR 2027

MUFI: Hidden-State Transfer for Multi-Fidelity Mesh PDE Surrogates via Coarse Propagation and Fine Decoding

Abstract

High-resolution mesh PDE surrogates face a mismatch between geometric resolution and the resolution required for physical propagation. Fine meshes are often necessary to represent boundaries and localized structures, while global communication over all fine nodes can introduce substantial computational cost. This raises a key question in multi-fidelity surrogate modeling: what information should be transferred across fidelity levels to reconstruct fine-resolution fields? We introduce MUFI, a coarse-propagation/fine-decoding framework that studies hidden-state transfer across mesh resolutions. MUFI runs an existing mesh surrogate backbone on a coarsened mesh, transfers its intermediate hidden representations through a cached geometry-aware sparse operator, and reconstructs the solution on the original mesh using a FiLM-conditioned neural field decoder. Unlike coarse-field transfer approaches that only propagate predicted outputs, MUFI preserves pre-readout backbone states generated during physical propagation. A matched coarse-field transfer control indicates that hidden-state transfer provides additional reconstruction benefits beyond coarse propagation and decoder capacity alone. Across CFD and CSD benchmarks from the PLAID datasets, multiple mesh surrogate backbones, and a varying-geometry surface benchmark, MUFI improves the accuracy-cost trade-off and provides controllable operating points through fidelity selection. These results indicate that the choice of transferred representation is an important design factor in multi-fidelity mesh surrogate learning.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Neural PDE Surrogates, Multi-Fidelity Learning, Hidden-State Transfer, Graph Neural Networks, Neural Fields, Unstructured Meshes, Computational Fluid Dynamics, AI for Science.

Reviews

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

This paper proposed GI-RBF, a decoupled offline-online framework that uses Gaussian EBF to represent PDE solutions. The method includes a task conditioned generative initializer to predict the RBF parameter set which includes the coefficients, centers, scales, orientations and geometry. In the offline stage, the initializer is trained with solution supervision with short physics based optimization trajectories. In the online stage, its predictions are further refined through steps of physics-informed optimization. Experiments were conducted on four PDE families and a flow-mixing problem. With a matched online refinement budget, their method improves over PINN parameter methods and standard RBF initialization.

Critical strengths

1.The framework shows good compatibility with different backbone architectures: MGN, MGN-Tree, MiSE-GNN, Transolver, making it a useful wrapper beyond specific GNN designs. In addition the experiment coverage and scope are comprehensive: different PDE domains and multiple CFD and CSD datasets AND varying geometry 3D surfaces. The examination of local physics such as shock, force, stress are very helpful information to analyze the tradeoff inherent in this method.

2.The pipeline depends heavily on FiLM, thus the controlled experiments of Field-FILM was informative in isolating the effect of hidden state transfer. Other analysis experiments were also helpful, especially the fidelity sweep (table 2-3) offers insight into the tradeoff between finer and coarse mesh information propagation.

3.The paper provides a detailed analysis of computational cost. Information including inference latency, preprocessing overhead are helpful in clarifying the computation requirement of the method.

Critical weaknesses

1.The novelty of the method might be limited. There have been multiple prior methods that used low-fidelity or latent propagation with fine reconstruction for high resolution mesh solution. The author will need to elaborate on the technical contribution compared to existing work.

2.In attributing the gain to hidden-state transfer, the author compared against the hidden representation and the physical output. However this experiment also changed the representation bandwidth (80 channels versus a few fields), so it is unsure whether the benefit of hidden state is that it transfers much more information.

3.The claim that coarse mesh can expand on fixed message-passing depth needs more investigation. Coarsening simultaneously changed multiple elements such graph connectivity and regularization, thus a better accuracy might not be directly attributed to the receptive field.

4.The coarse-to-fine reconstruction can lose important localized physical information. The robust alignment method in the paper can only address the error when interpolating coarse hidden states back to fine nodes, but not when coarsening the original mesh. This limitation is also reflected in the high Mach error in Table 4. Although the global RMSE improvement is valid, the degradation in local physical quantities may limit the application of the method in many settings.

Questions for authors

1.Compared with existing coarse-to-fine latent methods like GINO, UPT, Multiscale MeshGraphNets, what is the new technical contribution that MUFI made and how does it differ from existing work?

2.Since the hidden-state-transfer experiment also changed representation bandwidth, can the author add a controlled experiment while controlling the representation dimension?

3.Can the author compare propagation on the coarse mesh to a fine-resolution GNN with long-range edges, hierarchical shortcuts or more propagation depth? I am curious about why a coarser propagation can improve accuracy compared with the fine-mesh backbone, more direct evidence will strengthen the paper claim.

4.I am also wondering if there are potential conflicts between the fine and coarse supervision training objective? Table 31 shows that the auxiliary coarse loss can improve accuracy, however these two objectives might not always be aligned. Can the author discuss this point further or provide a sensitivity analysis?

5 comments
AuthorsOpenReview ↗

Response to Reviewer AfQr (1/3)

We sincerely thank the reviewer for the clear and well-targeted questions.

Q1 / W1. Difference from GINO, UPT and Multiscale MeshGraphNets; main contribution.

The three methods are new end-to-end architectures, whereas MUFI is a wrapper around an existing one. Technically:

  1. Backbone. GINO (graph-neural-operator encoder → FNO on a regular latent grid → graph-neural-operator decoder), UPT (pooling to sampled supernodes → latent transformer → cross-attention decoder at query points) and Multiscale MGN (message passing on a fine and a coarse graph) each define their own processor. MUFI keeps MGN, MGN-Tree, MiSe-GNN or Transolver unchanged, with the same hyperparameters (Table 9), and only moves it to a coarse mesh.
  2. Where coarsening happens. GINO and UPT compress inside the architecture, to a regular latent grid or a sampled set of supernodes, and Multiscale MGN adds a coarse level while still passing messages on fine edges. MUFI coarsens outside the backbone: the backbone receives a body-fitted remeshed coarse mesh that keeps the boundary representation. Its resolution is an explicit accuracy–cost knob (Figure 2, Table 3).
  3. What is transferred and how it is decoded. GINO and UPT decode from grid or token latents through learned integral or attention operators. MUFI transfers the backbone's own pre-readout node states through a fixed, cached sparse operator and decodes pointwise with FiLM. This design is what makes the question "what should be transferred?" testable at matched cost.

Because MUFI is a wrapper, these architectures are not alternatives to it but possible backbones for it. Each provides what MUFI requires from a backbone, a hidden state at every node before the readout (Section 3). Within MUFI, GINO, UPT or Multiscale MGN would run unchanged on the coarse mesh, keeping its own internal compression, and MUFI would transfer its pre-readout state to the original mesh. The closest tested cases are in Table 2: MUFI improves the multiscale MGN-Tree on all four 2D datasets, and Transolver, which attends over a compressed set of learned tokens as UPT does, on all four 2D datasets and on Rotor37 (Table 5).

The two parts of the contribution are linked. The primary contribution is the controlled finding of what to transfer when an unchanged backbone is moved to a coarse mesh: a learned pre-readout state rather than the coarse prediction (Table 1, new Tables R1 and R4). The backbone-agnostic wrapper is what makes this finding reusable as an accuracy–cost knob (Table 2, Rotor37). The alignment operator and FiLM decoder are the design choices that make the interface work and are ablated (Table 6), but we do not claim them as standalone contributions.

AuthorsOpenReview ↗

Response to Reviewer AfQr (2/3)

Q2 / W2. Bandwidth-controlled comparison.

Thank you for this suggestion. In Table 1, each model predicts a single field, so Field-SR-FiLM transfers 1 channel and MUFI 80: the comparison changes both the content (post-readout prediction vs pre-readout state) and the width of the transferred representation. To separate the two, we ran a bandwidth-controlled variant in the Table 1 setting. A second head, with the same architecture as the native readout, maps ZcZ_c to a single channel. This channel receives no coarse loss and is free to encode any information, while the native readout keeps its coarse loss. The 1-channel state is then aligned and fed to the same FiLM decoder. It has the width of Field-SR-FiLM and the content of a learned pre-readout state. We also tested an 8-channel linear projection of ZcZ_c.

Table R4. 2D_Profile, MiSe-GNN, L3, Temperature RRMSE, mean ± std over three seeds. Same coarse mesh, alignment, decoder and protocol.

Transferred to the decoderContentWidthRRMSE
MY^cM\hat{Y}_c (Field-SR-FiLM)coarse prediction10.01836 ± 0.00088
learned 1-channel head on ZcZ_cpre-readout state10.01591 ± 0.00056
linear projection of ZcZ_cpre-readout state80.01502 ± 0.00076
MZcMZ_c (MUFI)pre-readout state800.01507 ± 0.00054

The key result is that a learned 1-channel state, with exactly the bandwidth of Field-SR-FiLM, already recovers 74% of MUFI's gain over it (13.3% lower error than the coarse prediction). Eight channels recover all of it. In this setting, the gain therefore comes mainly from what is transferred: a state learned for fine reconstruction, rather than one constrained to be the coarse prediction. We will add this control to Section 4.2.

Q3 / W3. Why can coarse propagation improve accuracy?

All three requested variants are addressed: hierarchical shortcuts and added edges by two fine-resolution baselines already in Table 2, and greater depth by a reach analysis. MGN-Tree adds hierarchical shortcuts (multiscale tree edges; Ripken et al., 2023), and MiSe-GNN augments the fine graph with error-guided edges (Nguyen et al., 2026). Both extend communication beyond MGN's mesh edges at the same 15 steps, and MUFI still improves both (MGN-Tree on 4/4 datasets, MiSe-GNN on 3/4). For greater depth, we measured reach directly (Table R5): on VKI-LS59, 30 steps on the original mesh still reach less far than 15 steps at L3. Doubling the depth would also roughly double the processor cost of full-resolution MGN, which is already 4.3× slower per epoch than MUFI-MGN (153.86 s vs 35.90 s).

Table R5. Reach of kk message-passing steps on the mesh graph, VKI-LS59. Median over 1,000 source nodes per mesh, 168 meshes.

Mesh (nodes)Steps kkReach radius / chordDomain area reached
Original (36.4k)150.132.5%
Original (36.4k)300.268.5%
L3 (4.3k)150.2917.6%

For message-passing backbones, the evidence supports reach as one factor. Besides Table R5, the three GNNs differ substantially at full resolution on VKI-LS59 Mach (0.0322, 0.0217, 0.0190), whereas their L3 MUFI variants converge (0.0141, 0.0135, 0.0139): the spread shrinks from 0.0132 to 0.0005, consistent with reduced under-reaching (Section 4.3). Reach is not the only factor, however. MUFI also improves Transolver (−11.7% to −40.6%, Table 2), which attends globally at every resolution, and decoder capacity alone does not explain the gains: the full-resolution backbone with the same FiLM decoder remains worse than MUFI (0.01797 vs 0.01507 in the Table 1 setting). As you point out, coarsening also changes the graph connectivity and the regularization; our experiments do not separate these effects. We will revise Section 4.3 to present reach as one supported factor for message-passing backbones and to state this limitation.

AuthorsOpenReview ↗

Response to Reviewer AfQr (3/3)

W4. Loss of localized information through coarsening.

The alignment is not meant to compensate for coarsening: it transports the backbone state to the fine mesh, while the fine geometry reaches the decoder directly, through the coordinates and input features (node type, signed distance) of every fine node (Eq. 2). Coarsening therefore sets the resolution of the propagation, not the geometric information available for reconstruction, and the level is chosen like the mesh density of a numerical solver. Its effect on local quantities is measurable and positive in most cases: all models are trained on the global field loss and the local diagnostics are used for evaluation only, yet at the levels of Table 2, MUFI improves 35 of the 52 local diagnostics of Tables 20–23. This includes the high-gradient Mach error for all four backbones on VKI-LS59 and for the three GNNs on 2D_Profile. The Mach case you point to in Table 4 is specific to Transolver on 2D_Profile. A likely explanation (Section 4.4) is that Transolver already attends globally, so coarsening removes resolution near the shock without a gain in reach, whereas the message-passing backbones improve the same quantity on the same mesh. Where a local quantity matters, the level can be selected for it on the validation split: in our reply to Reviewer Fq47 (W3, Table R3), this rule keeps full resolution in that case and selects coarser, faster levels where the quantity is preserved.

Q4. Possible conflict between the fine and coarse objectives.

The coarse loss is not required by the interface; it regularizes the state passed to the fine decoder. The two targets come from the same solution: YcY_c is the fine ground truth interpolated to the coarse nodes (Section 3.1), so both losses can be zero at the same time and the targets themselves do not compete. The losses also act on different outputs: LcL_c reaches ZcZ_c only through the readout, so the transferred state is anchored to the physical solution without being forced to equal the coarse field. Forcing it, as Field-SR-FiLM does, is less accurate, even at equal width (Tables R1 and R4). Table 31 supports this role. The coarse loss improves all four decoders, and most for the FiLM and cross-attention decoders (−25% and −20%, versus at most 3% for the others), which condition most directly on the transferred state. The same untuned weights, L=Lf+LcL = L_f + L_c, are used in every experiment of the paper, and we see no sign that the two objectives work against each other at this weighting. We will add a sweep of the weight to Appendix F.6 and discuss this point in Section 3.5.

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

This paper studies how to reduce the computational cost of mesh-based PDE surrogates while maintaining prediction accuracy on fine meshes. MUFI runs an existing backbone on a coarsened mesh, transfers its hidden node representations through a cached, geometry-aware sparse operator, and reconstructs the physical fields on the original mesh using a FiLM-conditioned decoder. The backbone and decoder are trained jointly with losses on both coarse and fine predictions. Experiments cover four backbones on four 2D benchmarks and two backbones on a varying-geometry 3D surface benchmark. The results generally improve the accuracy–cost trade-off, while also revealing limitations for localized flow and stress features.

Critical strengths
  • A clear problem formulation and a reusable interface. The paper separates the resolution used for information propagation from the resolution used for prediction. Its central design choice—transferring hidden representations before the prediction head—provides a concrete alternative to transferring coarse predicted fields. The framework preserves the backbone’s internal propagation mechanism and can accommodate different architectures that expose spatially indexed hidden states. (Section 3)

  • A useful controlled experiment on the transferred representation. Table 1 compares hidden-state transfer with coarse-field transfer using the same coarse mesh, alignment operator, decoder width, and training protocol, with parameter counts differing by approximately 1.7%. Hidden-state transfer reduces Temperature RRMSE by 18.7% in this setting. The additional full-resolution backbone with a FiLM decoder also helps assess whether increased decoder capacity alone explains the improvement. (Section 4.2)

  • Broad framework evaluation and transparent reporting of limitations. Across the 16 backbone–dataset comparisons in Table 2, MUFI improves macro RRMSE in 15 cases and reports lower epoch times in all cases. The paper supplements these results with fidelity sweeps, 3D surface experiments, selected three-seed checks, localized physical diagnostics, and preprocessing and inference accounting. Reporting cases where global error improves but local physical errors worsen makes the practical assessment more informative. (Sections 4.3–4.6; Appendices C–G)

Critical weaknesses
  • The central attribution experiment has limited coverage. The matched comparison between hidden-state and coarse-field transfer is reported only for Temperature on 2D_Profile with MiSe-GNN at Level 3, without repeated-run statistics for this comparison. Most decoder and loss ablations also focus on Temperature at Level 2. These experiments support the interface choice in the tested setting, but the broader backbone results do not establish that its advantage over coarse-field transfer generalizes across architectures and physical problems. Extending the matched comparison to another physical task, with repeated runs, would substantially strengthen this claim. (Table 1; Appendix F)

  • The advantage over closely related latent-space approaches remains insufficiently established. Latent-space processing, conditional neural fields, FiLM, and auxiliary supervision are established ideas. The contribution therefore lies primarily in the specific transfer interface and its integration with existing backbones. Although Section 2 discusses related methods such as GINO and UPT, the main experiments compare MUFI with its underlying full-resolution backbones and custom transfer controls. A controlled comparison with one representative, closely related approach would help clarify the distinctive benefits of the proposed framework. The heterogeneous leaderboard comparisons in Appendix I do not resolve this question.

  • Local physical accuracy remains sensitive to fidelity selection. Improvements in macro RRMSE do not consistently extend to application-relevant local quantities. For example, the high-gradient Mach error increases substantially for MUFI-Transolver on 2D_Profile, and some backbone–dataset combinations show worse stress errors near holes. The authors clearly disclose these failures, but do not provide a validated rule for selecting a fidelity level that preserves the quantity of interest. This limits practical use when shock structure or stress concentrations matter more than average field error. (Section 4.4; Tables 20–23)

Questions for authors

Please refer to weaknesses.

4 comments
AuthorsOpenReview ↗

Response to Reviewer Fq47 (1/2)

We sincerely thank the reviewer for a precise and constructive review.

W1. Coverage of the attribution experiment.

We ran the suggested extension and broadened it. The matched comparison now covers four datasets: 2D_Profile and VKI-LS59 (2D flow), Tensile2D (solid mechanics) and Rotor37 (3D varying-geometry flow). It also covers all four backbones, and both single-field and multi-field models, with three seeds per arm. In each setting, both arms share the coarse mesh, alignment operator, decoder width and protocol; only the transferred quantity differs.

Table R1. RRMSE on the original mesh, mean ± std over seeds 42/43/44. Rel. change = (MUFI − Field-SR)/Field-SR; negative favors hidden-state transfer. Channels = width of MY^cM\hat{Y}_c / width of MZcMZ_c. Bold: the difference exceeds the seed std of both arms. The Rotor37 MUFI values are the three-seed runs of Table 5.

SettingOutputChannelsField-SR-FiLM (MY^cM\hat{Y}_c)MUFI (MZcMZ_c)Rel. change
Single-field models
2D_Profile, MiSe-GNN, L3Temperature1 / 800.01836 ± 0.000880.01507 ± 0.00054−17.9%
VKI-LS59, Transolver, L3mach1 / 1280.01822 ± 0.000340.01226 ± 0.00065−32.7%
Tensile2D, MGN, L1sig111 / 800.00380 ± 0.000100.00415 ± 0.00038+9.2%
Tensile2D, MGN-Tree, L1U11 / 800.00237 ± 0.000010.00232 ± 0.00015−2.1%
Multi-field models (3 fields jointly, macro RRMSE)
Rotor37, Transolver, L13 fields3 / 1280.00689 ± 0.000150.00583 ± 0.00017−15.4%
Rotor37, MGN, L23 fields3 / 800.00793 ± 0.000450.00659 ± 0.00019−16.9%

Across six matched comparisons covering four datasets, four backbones, flow and solid mechanics, and single- and multi-field prediction, hidden-state transfer is never worse beyond seed variability. It lowers the error by 15–33% in the four flow settings, by margins of 3 to 9 times the larger seed standard deviation. On Tensile2D (solid mechanics), the two transfers perform on par: the differences (+9.2% and −2.1%) are within seed variability. On Rotor37, coarse-field transfer does not even improve on the full-resolution backbones (Transolver 0.00677, MGN 0.00779; Table 5), whereas hidden-state transfer does. We also ran a bandwidth-controlled variant in the Table 1 setting (reply to AfQr, Table R4): at equal width, the pre-readout state keeps most of its advantage.

Two related results were already in the appendix. First, coarse-field transfer was also tested at Level 2: projecting the coarse prediction (0.0294) and residual decoding anchored on it (0.0180) are both worse than hidden-state decoding (0.0157; Tables 24–25). Second, the stencil-quality and stencil-size ablations are also reported on 2D_MultiScHypEl (Tables 29–30).

W2. Comparison with a closely related latent-space approach.

We agree that MUFI's novelty does not come from a new latent-space architecture. Rather, the contribution is the identification and validation of a transfer interface that consistently improves several backbone families. MUFI is a wrapper, not a new backbone: it changes the mesh a given backbone runs on and what is carried back to the original mesh, and leaves the backbone's propagation unchanged. GINO, UPT and Multiscale MGN could themselves be wrapped by MUFI, since each provides a hidden state at every node before the readout (Section 3). A direct comparison with them would therefore compare backbones rather than test MUFI; the controlled question is whether MUFI improves a backbone of each related family. Table 2 contains one for each:

  • Hierarchical/multiscale graphs (the family of Multiscale MGN): MUFI-MGN-Tree improves MGN-Tree on all four 2D datasets (−35.5%, −62.1%, −40.5%, −0.7%). The smallest gain holds over three seeds (Table 19).
  • Global attention over a compressed set of latent tokens (as in UPT): MUFI-Transolver improves Transolver on all four 2D datasets (−11.7% to −40.6%) and on Rotor37 (0.00677 ± 0.00008 → 0.00583 ± 0.00017 over three seeds, Table 5).

The alternatives for what is transferred and how it is decoded are compared within MUFI at matched cost: coarse-field transfer (Table R1), residual decoding over a projected coarse field, and concatenation, cross-attention, geo-attention and SIREN decoders (Table 6). We will add to Section 2 a short comparison of GINO, UPT, Multiscale MGN and MUFI (where propagation runs, what is transferred, whether an existing backbone is reused), and state that the three can serve as backbones within MUFI.

AuthorsOpenReview ↗

Response to Reviewer Fq47 (2/2)

W3. Rule for fidelity selection.

We agree that disclosing a local degradation is only useful in practice if it can be detected before deployment. When the global field error is what matters, the level is simply the accuracy–cost knob of Figure 2 and Table 3. When a specific local quantity matters, the level should be selected for that quantity. This only needs the validation split already in our pipeline and an accuracy requirement on the quantity, as in an engineering acceptance test. Among the trained MUFI levels, the rule selects the coarsest one whose validation error on the quantity meets the requirement, and keeps full resolution only if none does. No full-resolution model has to be trained for the check, and screening several levels is cheap: on 2D_Profile, all three MUFI-MiSe levels together cost less per epoch than one full-resolution MiSe-GNN (182.6 s vs 196.7 s). To test the rule on cases of Table 4, we set the requirement to "at least as accurate as the full-resolution backbone". At the levels of Table 2, MUFI already improves 35 of the 52 local diagnostics of Tables 20–23; Table R3 focuses on the cases where it degrades the target quantity.

Table R3. The rule applied to four cases of Table 4: two where MUFI improves the target quantity and two where it degrades it. Requirement: the full-resolution validation error. The level is selected on the validation split; all errors are on the test split. Speedup: epoch time of the selected level relative to full resolution (same timing scope as Table 3).

CaseTarget quantityLevelsSelectedTest: full res.Test: Table 2 levelTest: selectedSpeedup
2D_Profile, MiSe-GNNMach, top-5% gradientFull, L1–L3L30.3750.302 (L2)0.3575.82×
VKI-LS59, MiSe-GNNMach, top-5% gradientFull, L1–L4L40.09360.0822 (L3)0.07946.97×
2D_Profile, TransolverMach, top-5% gradientFull, L1–L3Full0.2270.924 (L2)0.2271×
2D_MultiScHypEl, MGN-TreePiola stress, near holesFull, L1Full0.07730.1053 (L1)0.07731×

In the two improving cases, the rule selects a coarser level than Table 2 and keeps the quantity more accurate than at full resolution, with 5.8× and 7.0× faster epochs. In both degrading cases, the macro error improves (Tables 19–20), so a selection by macro error would have missed the degradation. The rule detects it on the validation split and keeps full resolution, which avoids the Mach error of 0.924 for Transolver and the near-hole stress error of 0.1053 for MGN-Tree. We will add the rule and Table R3 to Section 4.4.

Reviewer_Fq47OpenReview ↗

Response to authors' rebuttal

Thank you for running the additional experiments. The three-seed comparisons in Table R1 clarify where hidden-state transfer helps, and Table R3 addresses my concern about choosing a mesh resolution when local accuracy matters. A direct comparison with GINO or UPT would still be useful, but I appreciate the clarification of MUFI’s contribution. I maintain my recommendation of weak acceptance.

Thank you for the follow-up and for the positive assessment. We are glad that Tables R1 and R3 address your concerns, and we will include both in the revised paper.

Reviewer_nQfxOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

MUFI aims to reduce the cost of predicting physical fields on fine meshes. It runs an existing backbone on a coarse mesh, maps the hidden node features to the fine mesh, and uses a FiLM-conditioned decoder to predict the final field. Its central claim is that transferring hidden features works better than transferring the coarse predictions themselves. The evaluation includes four backbones on four 2D datasets, together with a varying-geometry 3D surface dataset.

Critical strengths

1.The proposed MUFI gives existing backbones a clean interface between coarse-mesh computation and fine-mesh reconstruction: the backbone supplies its hidden node states, and the alignment operator with the FiLM decoder recovers predictions on the original mesh. That lowers the computational burden of a surrogate without touching how it propagates. 2. The paper shows comprehensive experimental results to validate the effectiveness of the proposed method. Table 2 shows lower macro RRMSE in 15 of 16 backbone–dataset comparisons and faster epochs in all 16. The evaluation also covers varying-geometry 3D surfaces and a few three-seed checks.

Critical weaknesses
  1. The central claim about hidden-state transfer gets little direct validation. Table 1 supports it for one temperature field with MiSe-GNN at one mesh level, and nothing more. It doesn't establish whether the advantage over coarse-field transfer holds for the other tasks or backbones.
  2. The supplementary code doesn't match the described pipeline. The supplied MiSe training path has incompatible function calls and inconsistent normalization of coarse targets, so the central experiments are hard to reproduce.
  3. The trainer logs epoch duration before online graph rebuilding and prints a separate total that includes it. But the timing scope isn't discussed, especially which scope fed the tables and training-budget curves.
Questions for authors

See Weaknesses.

2 comments
AuthorsOpenReview ↗

Response to Reviewer nQfx (1/2)

We sincerely thank the reviewer for the careful reading and for running our code.

W1. The hidden-state claim is validated in a single setting.

The paper already tests coarse-field transfer at a second level (L2, Appendix F). Projecting the coarse prediction to the fine mesh gives 0.0294, and residual decoding anchored on that projection gives 0.0180, versus 0.0157 for direct hidden-state decoding (Tables 24–25). We have now extended the matched comparison to four datasets, all four backbones, and both single-field and multi-field models, with three seeds per arm. In each setting, both arms share the coarse mesh, alignment operator, decoder width and training protocol; only the transferred quantity differs.

Table R1. Matched comparison. RRMSE on the original mesh, mean ± std over seeds 42/43/44. Rel. change = (MUFI − Field-SR)/Field-SR; negative favors hidden-state transfer. Channels = width of MY^cM\hat{Y}_c / width of MZcMZ_c. Bold: the difference exceeds the seed std of both arms. The Rotor37 MUFI values are the three-seed runs of Table 5.

SettingOutputChannelsField-SR-FiLM (MY^cM\hat{Y}_c)MUFI (MZcMZ_c)Rel. change
Single-field models
2D_Profile, MiSe-GNN, L3Temperature1 / 800.01836 ± 0.000880.01507 ± 0.00054−17.9%
VKI-LS59, Transolver, L3mach1 / 1280.01822 ± 0.000340.01226 ± 0.00065−32.7%
Tensile2D, MGN, L1sig111 / 800.00380 ± 0.000100.00415 ± 0.00038+9.2%
Tensile2D, MGN-Tree, L1U11 / 800.00237 ± 0.000010.00232 ± 0.00015−2.1%
Multi-field models (3 fields jointly, macro RRMSE)
Rotor37, Transolver, L13 fields3 / 1280.00689 ± 0.000150.00583 ± 0.00017−15.4%
Rotor37, MGN, L23 fields3 / 800.00793 ± 0.000450.00659 ± 0.00019−16.9%

Across six matched comparisons covering four datasets, four backbones, flow and solid mechanics, and single- and multi-field prediction, hidden-state transfer is never worse beyond seed variability. It lowers the error by 15–33% in the four flow settings, by margins of 3 to 9 times the larger seed standard deviation. On Tensile2D (solid mechanics), the two transfers perform on par: the differences (+9.2% and −2.1%) are within seed variability. On Rotor37, coarse-field transfer does not improve on the full-resolution backbones (Transolver 0.00677 ± 0.00008, MGN 0.00779 ± 0.00004; Table 5), but hidden-state transfer does. There, the accuracy gain of the wrapper comes from the transferred state, not from coarsening alone. In the Table 1 setting, a bandwidth-controlled variant (reply to AfQr, Table R4) further shows that the gain comes mainly from what is transferred, not from its width.

AuthorsOpenReview ↗

Response to Reviewer nQfx (2/2)

W2. Supplementary code.

We thank the reviewer for identifying these two implementation issues; both are now fixed.

  1. Function calls. The released MiSe-GNN trainer called the wrapper with an outdated signature. This is fixed; the MGN, MGN-Tree and Transolver paths were not affected.
  2. Normalization. All normalizations now follow the intended scheme: coarse targets with coarse-target statistics, fine targets with fine-target statistics. The fine loss, checkpoint selection (validation RRMSE on the fine mesh) and all reported errors already used fine statistics on the original mesh, so the correction concerns only the auxiliary coarse branch. Training of MGN, MGN-Tree and Transolver is unchanged. In MiSe-GNN, the coarse branch also estimates where the error is large; this estimate only decides where edges are added, to improve the coarse hidden state before transfer.

We reran Table 1 with the corrected code over three seeds: 0.01507 ± 0.00054 for MUFI and 0.01836 ± 0.00088 for Field-SR-FiLM. Both are within one standard deviation of the reported single runs (0.01561 and 0.01919), and the relative gap is unchanged (−17.9% vs −18.7%). These are the values in Table R1; the revised Table 1 will report them, and the corrected code will be released with the final version.

W3. Timing scope.

Including the graph rebuilding reduces the reported speedups, but MUFI-MiSe remains 1.8–4.9× faster per epoch than MiSe-GNN in every setting (Table R2). The online rebuilding is MiSe-GNN's own error-driven edge update, run every 10 epochs. It runs in both arms of every MiSe-GNN comparison: on the fine mesh for MiSe-GNN, and on the coarse mesh for MUFI-MiSe-GNN. All reported epoch times are the logged per-epoch duration (training pass + validation pass). This duration excludes the update in both arms, and Figure 3 is built from the same per-epoch durations. MGN, MGN-Tree and Transolver have no such step, so their timings are complete: 12 of the 16 comparisons in Table 2, Rotor37, and two of the three curves in Figure 3. For MiSe-GNN, both scopes are below.

Table R2. MiSe-GNN epoch time (s; A100, A30 for Tensile2D). "incl." adds the total edge-update time divided by the number of epochs.

SettingMiSe-GNN reportedMiSe-GNN incl.MUFI-MiSe reportedMUFI-MiSe incl.Speedup reported → incl.
2D_Profile L2196.70217.2753.6768.823.66× → 3.16×
2D_Profile L3196.70217.2733.8144.515.82× → 4.88×
VKI-LS59 L3375.24406.2869.6391.745.39× → 4.43×
Tensile2D L1132.34144.0362.0969.392.13× → 2.08×
2D_MultiScHypEl L1125.37170.9666.0894.161.90× → 1.82×

In Figure 3, with the update included, MUFI-MiSe reaches the final full-resolution error after ≈0.17× of the budget (reported: 0.15×). We will state the timing scope in Section 4.1 and report both scopes for all MiSe-GNN settings in Appendix G.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.