acceptodds
Under review as a conference paper at ICLR 2027

Tunable Non-linear Manifold ROMs for PDEs via Matrix-Free Petrov–Galerkin Projection

Abstract

The cost of a full-order PDE solve grows quickly as the mesh is refined, and neural operators such as Fourier Neural Operators and DeepONets generally provide only one accuracy-efficiency trade-off per trained model, and adjusting it requires retraining the model. We present a nonlinear-manifold reduced-order model (NM-ROM) whose query time grows far more slowly with the mesh than the full-order solver's, so its speedup grows as the mesh is refined, and whose balance between accuracy and speed is chosen when the model is used, not when it is trained. Its spatial bank, a set of learned spatial functions, is ordered once by importance after training, so a query chooses how many bank functions to use, and whether to solve with a nonlinear head or in the linear span of the bank, without changing a learned weight. For Burgers, Poisson and heat, the trained network can be used unchanged on meshes much finer than those it was trained on, while our POD-LSPG baseline has to be rebuilt for each mesh. The model is a coordinate-network bank with exact Dirichlet enforcement, solved by least-squares Petrov–Galerkin projection of the discrete residual onto fixed tests. Every linear term is precomputed, the solver runs matrix-free in JAX, and the nonlinear term uses empirical quadrature. On viscous Burgers and three-dimensional Navier–Stokes it is up to 27.5× faster than the full-order solver, and on linear Poisson and heat problems 108× and 216× faster at 0.83% and 0.13% worst-case error. On Burgers, refining the mesh from to raises its query time 2.6× and the solver's 74×. At the same latent dimension it is also more accurate than POD-LSPG and a quadratic manifold.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
reduced-order modeling, nonlinear manifold ROM, deployment-time tunability, least-squares Petrov–Galerkin, empirical quadrature, neural operators, scientific machine learning, parametric PDEs

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_8ZEFOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper proposes a runtime-tunable reduced-order modeling framework for efficient PDE solving. It combines a learned coordinate-based spatial bank with linear-span and nonlinear-manifold representations, using matrix-free Petrov–Galerkin projection for efficient online solving. The ordered spatial bank allows users to adjust the accuracy–efficiency trade-off without retraining. Experiments on Poisson, heat, Burgers, and Navier–Stokes equations demonstrate promising accuracy and speedups over full-order solvers and existing learning-based approaches.

Critical strengths
  1. Practical and flexible design. The ability to switch between linear-span and nonlinear-manifold representations and adjust the basis width at inference time is useful. The integration of coordinate-based spatial banks, precomputation, and hyper-reduction makes the framework computationally efficient.

  2. Strong empirical results. The experiments cover multiple PDE families and resolutions, demonstrating substantial speedups and encouraging cross-resolution performance. The comparisons with both conventional ROMs and neural operators provide useful evidence of the method's practical value.

Critical weaknesses
  1. Limited diversity of nonlinear evaluations. Although the paper includes Burgers and Navier–Stokes equations, the most accurate configurations for several tasks use the linear-span representation. Additional challenging nonlinear PDE benchmarks would help establish when the nonlinear-manifold component provides substantial benefits and how broadly the framework generalizes.

  2. Some limitations in baseline comparisons. The reported speedups depend on the selected full-order solvers, and the neural operator comparisons use different training data sizes and computational budgets in some settings. More closely matched comparisons would strengthen the empirical conclusions.

Questions for authors
  1. Could the authors provide additional experiments on more challenging nonlinear PDEs, particularly problems with stronger nonlinear dynamics, to further demonstrate the benefits of the nonlinear-manifold representation?

  2. Could the authors further clarify when the nonlinear head is preferable to the linear span, and whether its advantages extend beyond the current Navier–Stokes setting?

  3. How might the reported speedups change when compared with more optimized full-order solvers or neural operators trained under more closely matched budgets?

Minor Suggestion: The paper is generally well organized and easy to follow. However, Figure 1 could be more visually polished, with a cleaner layout, more consistent typography, and clearer separation between offline training and online inference. This would further improve the presentation.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 8ZEF

References below are to the revised manuscript.

Thank you for your constructive review. We have added nonlinear benchmarks, matched comparisons and clearer figures in response to your suggestions.

W1. Diversity of nonlinear evaluations

We added interacting-vortex Navier–Stokes with sharper initial data and lower viscosity (§5.1, Table 1), and unsteady cylinder flow (§5.2, Table 2). The fast Navier–Stokes head stays below 0.5 % worst-case error at 5.1–10.2× over its matched solver, while the same bank's linear span fails. The cylinder demonstrates non-box geometry and query-time width choices; it uses linear-span Galerkin and does not establish an additional nonlinear-head advantage.

W2. Fairness of the comparisons

We separate the comparisons: numerical solvers are matched to each setting's accuracy (§5.3), while neural operators are compared by prediction error under the reported training budgets. With the same 4,608 Burgers trajectories, our median error is 7–9× lower; operators have lower worst-case error (Table 4; Appendix F.2). The budgets do not establish convergence. Transform solvers win on box Poisson/3D heat.

Q1. Additional challenging nonlinear experiments

The added benchmarks are described under W1. Cylinder widths 24/32 retain all six targets over a window three times longer; extrapolation outside the training band remains limited (Table E.2). We state these limits alongside the results.

Q2. When is the nonlinear head preferable?

The head helps when few unknowns are affordable and a linear span fails (Figure 2). At 16 Burgers coordinates, errors are 2.56 % for the head, 56.9 % for a linear closure and 31.8 % for a quadratic one (Table F.3). A wider span can be faster; §5.5 explains this choice.

Q3. Stronger solvers and matched neural operators

W2 summarises the corrected comparison. For cylinder flow, FNO meets all targets on the standard window, but no tested operator does on the longer window or outside the training band (Table F.2). On Burgers 2D with the same training data, a bank refitted at width 512 has lower worst-case and median error than the FNO and U-Net runs (0.33 % and 0.035 % against 0.43–0.51 % and 0.19–0.23 %), also on 64 fresh cases; the refit is specific to that width (Table 4; Table F.4). The operator runs are those already reported under W2. Against accuracy-matched cuDSS and AmgX time steppers, our Burgers 2D settings are 1.2–2.5× and 2.6–8.3× faster, and 2.7–36× faster than cuDSS in 3D; AmgX is faster than our accurate 3D setting at 64³ (Table F.5). The accuracy–cost setting is chosen at query time from one trained bank. The reduced-solve time is essentially unchanged from 256² to 4096² (Figure G.3), while a full-order solve grows with the mesh, so the speedup at matched error increases with resolution: 3.3–4.3× at 256², 5.4–6.3× at 512² and 10.7–12.8× at 1024² over our error-matched full-order solver on Burgers 2D (development cases; Appendix F.4).

Minor suggestion. Figure 1

We redrew Figure 1 to separate offline training and online inference, with a cleaner layout and consistent typography.

Thanks for the additional experiments and clarifications. They address my main concerns, and I'll keep my positive rating.

AuthorsOpenReview ↗

Thank you, and a short note on Q3

Thank you for your positive assessment, and for taking the time to read our response. In case it is useful, here is a short summary of where the Q3 results ended up; no reply is needed.

With the same training data, a bank refitted at width 512 has lower worst-case and median error than the FNO and U-Net runs (Table 4; Appendix F.4). The accuracy-matched cuDSS and AmgX comparisons are in Appendix F.5. Because the reduced-solve time does not grow with the mesh, the speedup over our error-matched solver rises from 3.3–4.3× at 256² to 10.7–12.8× at 1024² on Burgers 2D (development cases). All of this is in the revised manuscript.

Reviewer_iMp8OpenReview ↗
Rating
1
Confidence
3(+1)
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

The paper proposes a reduced-order model for PDEs. The solution is a sum of R basis functions (small coordinate networks times a boundary factor) with coefficients from a small head network. After training, the basis is reordered by PCA so that the first R′ functions give a cheaper and less accurate model. At query time, the coefficients are found by minimizing the PDE residual, using precomputed linear terms and empirical quadrature. Tests on Poisson, heat, Burgers and 3D Navier–Stokes report speedups up to 27.5× (nonlinear) and over 100× (linear).

Critical strengths
  • Clear cost model: space and latent code are separated, so linear terms can be precomputed.
  • Timing setup is described in detail, with named baselines.
  • Limitations are partly acknowledged.
Critical weaknesses
  1. Weak motivation. The test problems (Poisson, heat, Burgers on a square or cube) are cheap to solve. Modern GPU solvers (FFT, multigrid, GPU finite elements) solve them in milliseconds to seconds with batch (cudss) and can generate thousands of samples in seconds to minutes. There is no point in solving these benchmarks and stressing speed nowadays.
  2. Limited novelty. All parts are known. Neural-field ROMs, hard Dirichlet enforcement.
  3. Mesh independence is overstated. For Navier–Stokes, the basis and head are rebuilt for each mesh. For other problems, there is still a per-mesh setup cost (up to 869 s).
  4. Small and weak evaluation. Test sets are small (6–64 cases), and timings have no spread.
  5. Poor presentation. The main text has one figure (a pipeline diagram). There are no solution plots, error maps, failure cases, or learned basis plots.
Questions for authors
  1. What is the total cost (data, training, setup), and how many queries are needed to break even?
  2. How is the basis loss defined, and are coefficients solved exactly at each step?
  3. Can it handle other boundary conditions and complex geometry without a hand-made boundary factor?
  4. Please compare with FFT/multigrid GPU solvers and show solution visualizations.
3 comments
AuthorsOpenReview ↗

Response to Reviewer iMp8

References below are to the revised manuscript.

Thank you for your review. We have strengthened the solver comparisons, clarified the scope and cost of the method, and added the requested visual evidence.

W1. Motivation and comparisons with modern solvers

We disagree that fast GPU solvers remove the motivation for reduced models. Our learned representation retains an online projected-PDE solve and targets repeated queries with query-time accuracy–cost control. The comparison is complete-query cost at matched accuracy.

Our Navier–Stokes head is 3.3–11.7× faster than the fastest accuracy-matched solver from a 450-entry GPU pseudo-spectral ladder; the fast width-192 setting gives 5.1–10.2× (Table 1; Appendix E.1). Incompressibility already uses modewise projection, so there is no sparse pressure system for multigrid or cuDSS to accelerate. Batching both codes gives 17× at 128³ and 75× at 64³ for batch 128, including our input/output work.

The scaling distinction matters: FFT diagonalisation requires compatible operators and geometry, and nonlinear evolution still requires time stepping. Multigrid and sparse-direct methods retain mesh-based systems. Our reduced solve is mesh-independent at fixed settings after assembly (Figure G.3); comparators may coarsen their mesh wherever accuracy permits.

For cylinder flow, we obtain 25–54× in rollout and 11–18× with output against the cheapest passing finite-element configuration on the same CPU node. Tested CPU AMG variants pass the same targets but are slower than reused sparse LU (Table 2; Appendix E.2).

We retain the measured limits: transforms win on box Poisson/3D heat, and input/output cost removes a consistent full-query advantage at 256³. The cuDSS and AmgX results are in our follow-up comment below.

W2. Contribution

The contribution is a physics-based reduced model with a query-time accuracy–cost ladder from one training run. Bank/head factorisation makes linear terms exact precomputed matrices and constrains online dynamics within the bank span. Figure 2 and Table F.3 isolate the head's benefit; Table 4 compares neural-field baselines. Sections 3 and 5.5 distinguish the contribution from established PCA ordering and quadrature.

W3. Mesh independence and setup

Mesh independence concerns the learned representation and reduced online computation. Per-mesh operator assembly is an explicit offline cost. Table E.1 demonstrates one coordinate bank across meshes, including unchanged-head reuse. Table 1 uses per-mesh POD and is labelled accordingly. Interpolated POD also transfers on periodic boxes; our claim does not require rebuilding POD on every mesh.

W4. Evaluation size and timing variability

Our main revised evaluation uses 128 fresh cases and three independently trained models (Table 1). Appendix C.4 reports timing spread; Table 2 gives five-repeat cylinder ranges. Speedups use the two seeds passing timing checks. The third seed's accuracy remains included, with its failed timing gate disclosed in Appendix E.1. Exploratory cohorts and failed retrains are labelled.

W5. Solution plots and presentation

We added a main-text head-versus-span comparison (Figure 2). Appendix G supplies solution fields, error maps, learned bases, failure cases, mesh scaling and break-even curves.

Q1. Total cost and break-even

We target repeated queries within one parameterised family. Appendix C.2, Table C.4 reports offline costs and break-even counts: about 1,800 queries for cylinder and 43,000 for Navier–Stokes at 128³. GPU-hours and CPU node-seconds are distinguished; missing data-generation costs are identified. Against transforms, box Poisson never breaks even, and heat 2D needs about 370,000 queries.

Q2. Basis loss and exact coefficient solves

We give the losses and weights in Appendix C.1, Eqs. (20)–(23) and Table C.3. Only heat 3D and Burgers 3D eliminate coefficients at every training step through thin QR. Heat 3D uses a weighted POD-mode mean and a snapshot-minibatch tail term. Other banks jointly train coefficients or latent codes, with the stated least-squares resets/phases. After freezing the bank, ordering coefficients and head targets are exact least-squares fits; online coefficients come from the projected PDE solve.

Q3. Geometry and boundary conditions

We demonstrate cylinder flow using smooth boundary-distance factors and an inflow lift in a Galerkin rollout (Appendix E.2). Automatic handling of arbitrary geometry and Neumann/Robin conditions remains untested.

Q4. FFT/multigrid comparisons and visualisations

See W1 for the numerical-solver comparisons and W5 for visualisations. The GPU sparse-solver results are in our follow-up comment below.

AuthorsOpenReview ↗

Update: cuDSS and AmgX results, and query cost across mesh sizes

Thank you again for suggesting the comparison with modern GPU solvers. The cuDSS and AmgX measurements are now complete and are included in the revised paper (Tables C.6 and F.5; Appendix F.5). We summarise them here.

Main observation: our query cost stays nearly constant as the mesh is refined. The online solve works on a fixed number of reduced unknowns, so only input and output depend on the mesh.

  • Poisson 2D: from 256² to 4096² (256 times more unknowns) our query goes from 0.18 to 0.45 ms. The cuDSS solve phase, with its factorisation reused, goes from 0.45 to 36.5 ms.
  • Burgers 2D: from 256² to 1024² our accurate setting goes from 29.3 to 30.8 ms; at 2048² it is 48.7 ms, the increase being input/output on the mesh. The reduced solve itself is essentially unchanged from 256² to 4096² (Figure G.3).
  • Consequence: a full-order solve grows with the mesh, so our speedup at matched error increases with resolution (figures under "A faster online solve" below).

Burgers (nonlinear, implicit time stepping), one H200 GPU. Each comparator entry is its fastest configuration whose worst-case error is at or below ours. The cuDSS stepper may coarsen its mesh by 2 or 4 and choose its time step; the AmgX stepper (BiCGStab with a block-Jacobi or algebraic-multigrid preconditioner) runs on the same mesh. Times in ms per query; in brackets, the comparator's time divided by ours.

MeshOurs, accurate / fastcuDSS, matched to accurate / fastAmgX, matched to accurate / fast
256²29.3 / 10.235.8 (1.2×) / 18.1 (1.8×)76.1 (2.6×) / 35.7 (3.5×)
512²29.4 / 10.073.6 (2.5×) / 19.6 (2.0×)114 (3.9×) / 68.5 (6.9×)
1024²30.8 / 12.576.4 (2.5×) / 19.7 (1.6×)185 (6.0×) / 104 (8.3×)
2048²48.7 / 19.680.9 (1.7×) / 40.8 (2.1×)not run
64³81.1 / 8.3221 (2.7×) / 162 (20×)40.5 (0.50×) / 14.9 (1.8×)
128³85.6 / 10.03,050 (36×) / 164 (16×)83.6 (0.98×) / 43.7 (4.4×)
  • 2D: our model is faster than both solvers at every mesh measured.
  • 3D: our model is 2.7–36× faster than the cuDSS stepper. The AmgX stepper is faster than our accurate setting at 64³ (40.5 ms at 0.04 % worst-case error against 81.1 ms at 1.0 %) and level with it at 128³; our fast setting is 1.8–4.4× faster. This is stated in the limitations.
  • For the accurate 2D setting, the strongest comparator remains the paper's own matrix-free solver (Table 3).

Poisson (one linear solve). With an offline compression of the trained bank (no retraining, test errors unchanged to six digits), a query takes 0.18 / 0.18 / 0.20 / 0.25 / 0.45 ms at 256² / 512² / 1024² / 2048² / 4096². The cuDSS solve phase with a reused factorisation takes 0.45 / 1.0 / 3.0 / 9.4 / 36.5 ms, and AmgX 13.9–140 ms (Table C.6). This comparison is on the same mesh and is not accuracy-matched: cuDSS is exact to rounding, while our accurate setting has 0.84 % worst-case error within the trained family. Sine-transform solvers remain faster on box problems, as the paper states.

A faster online solve, with no retraining. Reusing one Jacobian factorisation per query (Appendix A.4) makes the Burgers 2D solve 5.6–10× faster than the submission's solve at unchanged median error: at 256², width 384 goes from 46.0 to 5.4 ms (worst-case error 0.85 %, median 0.026 %), and at 1024² from 49.6 to 7.6 ms. Against the paper's own solver matched to the same error it is 3.3–4.3× faster at 256², 5.4–6.3× at 512² and 10.7–12.8× at 1024² (widths 96, 128 and 384; 38 development cases; Appendix F.4).

Protocol. Our model and the comparators were timed in separate jobs on the same GPU model. The cuDSS stepper was run on 64, 64, 16 and 8 cases at 256²–2048² and on 16 and 6 cases at 64³ and 128³; the AmgX stepper on 16 cases (6 at 128³). The cuDSS Poisson solve is in double precision.

Navier–Stokes timing. The third model's timing run passed on a third attempt: 8.3 / 10.1 / 5.9× for the fast width-192 setting, inside the reported 5.1–10.2×. Table 1's ranges are left at two seeds (Appendix E.1).

Thanks for the response to this paper. I still feel there is only a marginal speedup with this method over modern GPU solvers. I think there will be no advantage for large-scale problems. The headline results don't use the claimed contribution; the results of NS use a per-mesh POD bank, not a coordinate-network bank. coordinate-network bank still falls behind POD at 128^3. More importantly, there is substantial rewriting during the rebuttal. The abstract and main experiments are changed. These new results have not been fully reviewed. I think it is better suited for a resubmission. In summary, I will keep my score.

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

This paper proposes a reduced-order model for PDEs. It learns a spatial bank and a small nonlinear head, then solves the projected PDE residual at query time. The bank is ordered after training, so users can change its width or choose between the nonlinear head and the linear span to adjust accuracy and speed.

Critical strengths
  1. The separation of the spatial bank and the head makes linear terms easy to precompute and reduces the online cost.

  2. Choosing different bank widths without retraining is useful. The paper also reports failed settings and limitations clearly.

Critical weaknesses
  1. PCA ordering, operator precomputation and empirical quadrature are existing techniques. The paper does not directly compare with CROM or CoLoRA, although it identifies neural-field ROMs as its closest relatives. The gain over these methods is therefore unclear.

  2. The neural operator comparison is not well controlled. Appendix B states that Burgers operators use 128 training trajectories, while the proposed bank and head use 576 and 4608. The operators also have a 3000-second training limit; the heat FNO only completes 6-7 epochs at high resolutions (Table B.3). These differences make the accuracy comparison difficult to interpret.

  3. The reported speedups depend on the selected full-order solvers. Poisson and three-dimensional heat use unpreconditioned CG comparators. Also, Table 1 compares both model settings with a solver chosen to match the accurate setting. The fast setting therefore needs a separate comparison at a similar error level.

  4. Most headline results use the linear span. The nonlinear head works well on Navier-Stokes, but its bank is a POD basis, and both bank and head are built separately for each mesh (Appendix A.5). These results do not clearly establish the combined benefit of the nonlinear head and the mesh-independent coordinate bank.

Questions for authors
  1. Could the authors compare the neural operators using the same training trajectories and allow enough training to check whether the accuracy gap remains?

  2. How much speedup remains against a stronger full-order solver when each model setting is compared at a similar error level?

  3. Could the authors compare with a neural-field ROM and separate the gains from the coordinate bank, nonlinear head and hyper-reduction?

2 comments
AuthorsOpenReview ↗

Response to Reviewer 1dYR

References below are to the revised manuscript.

Thank you for your review. We have added the comparisons and ablations you requested and address the concerns and questions you raised below.

W1. Contribution and neural-field baselines

Our contribution is the bank/head factorisation: exact precomputed linear terms, a nonlinear constraint on bank coefficients, and nested widths from one training run. PCA ordering and quadrature are established techniques. We now compare with same-data re-implementations of CROM and CoLoRA (Table 4; Appendix F.1). Our head has 4–5.5× lower worst-case error and 16–87× faster queries than CROM, although CROM's accurate setting has lower median error. CoLoRA has lower worst-case error; our span has lower median error at slightly lower cost. CoLoRA receives initial-condition parameters; ours receives a field.

W2. Matched training data and budgets

We retrained FNO and U-Net on the same 4,608 trajectories, allowing up to 8.1 hours. We compare prediction errors here: our Burgers median error is 7–9× lower, while operators have lower worst-case error (Table 4; Appendix F.2). This is an accuracy-only comparison with direct prediction models; our online method solves the projected PDE. Most runs reached their time limit before convergence, so the results are budget-limited.

W3. Stronger, accuracy-matched solvers

We now match each setting to its own error. The fast width-192 head reaches 0.35–0.48 % worst-case error at 5.1–10.2× over the fastest equal-accuracy pseudo-spectral Navier–Stokes solver from 450 configurations (Table 1; Appendix E.1). Errors cover three models and 128 fresh cases; speedups use the two seeds passing timing checks. Section 5.3 and Appendix C.3 also disclose transform-solver wins on box Poisson/heat 3D and the original Navier–Stokes family's lack of consistent advantage after mesh coarsening.

W4. Coordinate bank and nonlinear head

Table 1 and Figure 2 use per-mesh POD banks. We separately test one coordinate-network bank across meshes: it matches POD at 64³/96³ but trails at 128³ (Table E.1). The earlier cohort and fallback selection after missing the preset rank-64 transfer tolerance are disclosed. Interpolated POD transfers equally well on periodic boxes, so we remove the claim that POD must be rebuilt per mesh.

Q1. Does the operator accuracy gap remain with matched training?

With the same 4,608 trajectories, our median error is 7–9× lower than FNO and U-Net (0.026 % against 0.19–0.23 %). With the submitted bank the operators have the lower worst-case error (0.43–0.51 % against 0.875 %). Refitting our bank on the same trajectories at width 512 closes this gap: 0.33 % worst-case and 0.035 % median error on the test cases, and 0.49 % against 0.57–0.90 % on 64 fresh cases (Table 4; Table F.4). The refit is specific to that width, and the operator runs are those reported under W2.

Two properties distinguish our model in this comparison. Accuracy and cost are chosen at query time from one trained bank: widths 176 and 384 give 0.12 % and 0.026 % median error in 2.7 and 5.4 ms with a reused Jacobian factorisation (Table 4; Appendix A.4), whereas each operator gives one trade-off per trained model. And the reduced-solve time is essentially unchanged from 256² to 4096² at fixed settings (Figure G.3), while a full-order solve grows with the mesh, so the speedup at matched error increases with resolution: 3.3–4.3× at 256², 5.4–6.3× at 512² and 10.7–12.8× at 1024² over our error-matched full-order solver on Burgers 2D (development cases; Appendix F.4).

Q2. How much speedup survives stronger solvers?

The new Navier–Stokes result is given under W3. Table 3 and Appendix C.3 report the corrected original comparisons, including cases where stronger solvers win.

Q3. What does each component contribute?

We added the neural-field comparisons in W1 and component ablations in Table F.3. At 16 Burgers coordinates, the head gives 2.56 % error versus 56.9 % for a linear closure and 31.8 % for a quadratic one. Sparse nonlinear evaluation reduces time at unchanged error. Appendix F.3 separates these gains from the coordinate bank's mesh-transfer role.

AuthorsOpenReview ↗

Update to Q1: operator comparison

Thank you again for your review. The update we announced under Q1 is now in our response above and in the revised manuscript (Table 4; Appendix F.4): with the same training data, a bank refitted at width 512 has lower worst-case and median error than the FNO and U-Net runs, on the test cases and on 64 fresh cases. The comparison with accuracy-matched cuDSS and AmgX solvers is in Appendix F.5.'

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.