acceptodds
Under review as a conference paper at ICLR 2027

underPINN: A Modular and Scalable JAX-Based Framework for Physics-Informed Machine Learning

Abstract

Physics-informed neural network (PINN) libraries have proliferated across PyTorch, JAX, and Julia, and cross-framework speed comparisons between them are increasingly common. We show that these comparisons are surprisingly fragile. Framework defaults that never appear in a problem's configuration file — weight normalization applied to every hidden layer, renormalization of the network's time input, dimension-restricted differential operators silently violate the “same architecture, same physics” assumption such comparisons rest on. Separately, we find that a single-run PINN ablation can reverse its conclusion under an identical random seed and identical code, as GPU floating-point non-determinism compounds through adaptive-collocation training dynamics. We present underPINN, an open-source JAX-native PINN framework, and use it as a controlled instrument for rigorously matched comparison. underPINN compiles each problem's optimization step — forward evaluation, automatic differentiation, and the optimizer update — once with jax.jit and reuses that executable every epoch; an optional jax.lax.scan-fused path yields no measurable further speedup once the step is compiled, which we report. Against eager-mode PyTorch on three matched reimplementations the compiled path is – faster, with the speedup tracking the ratio of per-epoch dispatch overhead to per-step compute rather than problem complexity. Against NVIDIA PhysicsNeMo Sym (eight matched problems) and jinns (six), underPINN is faster on every problem but only after the confounds above are identified and corrected, which we document as guidance for the field rather than a criticism of any one library. Through one configuration interface the framework also exposes Fourier-feature embeddings, gated MLPs, FBPINN domain decomposition, residual-adaptive collocation, a deterministic DEIM-inspired collocation selector (QR-DEIM-R), and a Levenberg–Marquardt-damped Gauss–Newton step. We test these across multiple seeds rather than assume they help, and report what the tests return. Residual-adaptive collocation improves accuracy only where a localized, uncapped feature exists to exploit, not on smooth or dissipation-capped problems. QR-DEIM-R does not reproduce the gains published for QR-DEIM-based collocation on any of the six problems we run it on, and tuned Adam matches or beats the Gauss–Newton step on both accuracy and wall-clock. Our nine problems span ODEs, elliptic and parabolic PDEs, 3-D pipe flow, and 1-/2-D compressible shock flows, and we report the failures alongside the successes including a 1-D blast wave whose relative error plateaus near . The compressible cases are solved data-free, from the governing equations and boundary conditions alone with no reference solution supplied during training: among them a Mach 3 viscous shock/boundary-layer-interaction ramp, and Toro Test 3, whose initial pressure ratio sits four orders of magnitude above the Sod- and Lax-type Riemann problems usual in the PINN shock literature.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Physics-Informed Machine Learning, JAX, Flax, Optax, Fluid Flows

Reviews

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

This paper presents underPINN, a modular JAX-based framework for physics-informed machine learning that integrates JIT-compiled training, multiple neural architectures, adaptive collocation strategies, and numerical optimization methods. Through comparisons with PyTorch, NVIDIA PhysicsNeMo, jinns, and DeepXDE, the authors demonstrate significant computational speedups while identifying hidden configuration differences and numerical nondeterminism that can undermine the reliability of cross-framework evaluations.

Critical strengths
  1. The paper addresses a relevant challenge in physics-informed machine learning: developing an efficient, extensible PINN framework while ensuring reliable and reproducible cross-framework comparisons.

  2. underPINN separates physical models, domain formulations, neural network architectures, optimization, and execution, making it easier to integrate different PDE problems and training strategies.

Critical weaknesses
  1. The core methodological novelty is limited. Most of the framework's major components, including JAX compilation, Fourier features, gated networks, FBPINN decomposition, adaptive collocation, and Gauss–Newton optimization, have already been studied extensively. The main contribution is their software integration and systematic evaluation rather than a fundamentally new learning algorithm.

  2. Higher computational throughput does not translate into better predictive accuracy. In Table 2, underPINN achieves the lowest mean prediction error on none of the five problems with comparable accuracy results across the evaluated JAX frameworks. This weakens the practical advantage of the proposed framework beyond training speed.

  3. The framework's native architecture support remains relatively limited, focusing primarily on conventional MLPs and their gated or Fourier-feature variants. Several influential developments in physics-informed learning, including PirateNets, PINNsFormer, PINNMamba, physics-informed Kolmogorov–Arnold networks (PIKANs), and separable PINNs (SPINNs), are not supported or evaluated. This limitation raises concerns about the framework's extensibility and its applicability to modern PINN research, particularly because some of these architectures require substantial changes to the computation or training pipeline rather than simply replacing the network backbone.

Questions for authors
  1. Could the authors demonstrate the integration of at least one non-MLP architecture without modifying the core training engine, and evaluate whether its computational efficiency and numerical accuracy are preserved?

  2. The PhysicsNeMo experiments disable its default JIT compilation due to hardware incompatibility, whereas underPINN benefits from JAX compilation. How representative are the reported speedups of a comparison between fully optimized implementations? Could the authors provide additional experiments on hardware where PhysicsNeMo's native compiled execution is supported?

1 comment

Thank you for the detailed review. We answer the soundness points first, then extensibility (Q1) with new experiments.

W1. Limited methodological novelty. We agree the building blocks are established, and the revision no longer presents their integration as the contribution. What is new (General Response §1):

  1. A matched audit of five PINN frameworks: hidden defaults silently break "same architecture" comparisons (PhysicsNeMo's weight normalization: 69× on Helmholtz).
  2. A structural account of PINN speedups: speedup tracks the dispatch-to-compute ratio, and torch.compile cannot capture the PINN double-backward.
  3. A five-seed, six-problem adaptive-collocation ablation.
  4. Data-free Toro Test 3 (10510^5 pressure ratio) and a Mach-3 viscous SBLI.
  5. New: failure diagnostics, which found a defect in our own PINNMamba.
  6. New: architecture gains shrink at equal wall-clock (below).

W2. underPINN is not the most accurate in Table 2. On matched problems all frameworks run the same algorithm, so accuracy gaps come from configuration. The paper traces each one: jinns' initializer (about half its Steady Heat advantage, A.10), DeepXDE's fixed collocation set, and our default learning rate on ODE Harmonic (Sec. 3.9). A framework that "won" at a matched configuration would signal a mismatch. The revision adds a same-initializer arm to Table 2. Time-to-accuracy is in our response to Reviewer 1.

Q2. PhysicsNeMo without its default JIT. A fair point. On GB10, nvFuser and TorchScript fail to compile; on A100 all paths work. Burgers, 3 seeds, ms/epoch: underPINN 1.8, eager PyTorch 5.78, TorchScript 7.69, torch.compile (Inductor) 12.82. torch.compile cannot capture the double-backward, so it needs the slower torch.func form. PhysicsNeMo with its own defaults (TorchScript activation, CUDA graphs; torch 2.5 has no nvFuser) takes 3.10. A100 becomes the primary comparison.

W3 / Q1. Non-MLP architectures without touching the training engine. Done. We added PirateNets, PINNsFormer, PINNMamba and Chebyshev and B-spline PIKANs as network modules, selected by network.type. No solver, loss or training-loop code changed. Data parallelism, restart and diagnostics work unchanged.

Parameter-matched (~130k), 3 seeds, best of two learning rates, 20k Adam epochs; median rel. L2L^2:

ConvectionReactionWaveBurgersAllen–Cahnms/ep
MLP0.848.5e-20.281.4e-30.721.1–2.4
PirateNet†0.102.3e-29.7e-26.7e-53.7e-22.0–4.2
PINNsFormer4.4e-2‡2.8e-20.265.3e-40.156–15
PINNMamba0.915.5e-21.502.8e-20.1919–81
PIKAN (Cheb.)0.632.3e-20.301.8e-40.141.3–3.6

† Without its least-squares output initialization, which hurt transport problems. ‡ Two of three seeds.

PirateNet and PIKANs cost 1.2–2× the MLP per epoch. The sequence models cost 5–30×, from their architecture, not our pipeline.

A cautionary result. At equal wall-clock, with a standard recipe (causal weighting, gradient-norm balancing, L-BFGS finish) for all models, most gains vanish. PirateNet's 4.9× Allen–Cahn advantage becomes 0.9×, and a plain MLP solves convection (7.7e-3). Only the gated models keep a clear gain on wave (2.4–4×).

SPINN. It needs a different pipeline (per-axis forward-mode derivatives on factorized grids), so we implemented it separately and tested it against autodiff. It is a different network: 3×64 per axis, 64 separable terms. On Helmholtz it takes 0.47 ms/epoch and reaches 2% error in 1.5 s, about 4× sooner than the fastest framework. On Burgers it does not reach 1% error in 20,000 epochs, with fixed or per-step resampled points (final 6–16%).

Presentation. The main text now reports final results; revision history moves to an appendix.

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

This paper introduces a software framework that uses JAX to train PINNs. The goal is to have speed, flexibility, and provide fair evaluation over existing frameworks. No new methods are presented, existing methods are combined to improve execution and to test when these methods help. The main benefit is of speed improvement over existing libraries/implementations.

Critical strengths
  • Useful software design for PINNs. One framework supports it all.
  • Good speed measurements and benefit.
  • Multiple training runs on the selected benchmark.
Critical weaknesses
  • Only one GPU is tested: for a evaluation study with a software framework, I would have liked to see multiple GPUs.
  • No GPU memory measurements reported and compared.
  • I would have liked seeing extensive benchmark such as PINNacle included.
Questions for authors

see weaknesses

3 comments

Thank you for the positive assessment. Your three weaknesses identify real gaps. W1 and W3 are now addressed with new results; W2 is addressed on two problems.

What is new beyond speed (General Response §1): a matched audit of five frameworks that exposes hidden defaults invalidating comparisons (e.g. PhysicsNeMo's weight normalization: 69× on Helmholtz); a structural account of when compilation speeds up PINNs; a five-seed adaptive-collocation ablation; and data-free Toro Test 3 and Mach-3 SBLI benchmarks.

New since submission: failure diagnostics, a five-architecture evaluation, and the multi-GPU data parallelism below (exact gradients, equal to single-device full-batch training, tested on 1–8 GPUs).

W1. Multi-GPU evaluation. We added exact-gradient data parallelism. Collocation batches are split across devices and parameters replicated, so the gradient equals single-device full-batch training up to float32 reduction order; loss trajectories agree to 5–6 significant digits across 1–8 GPUs. We measured strong and weak scaling on one 8× A100-40GB node (1-D Burgers, 3 seeds of timing, steady state excluding compilation).

Strong scaling, speedup on 8 GPUs vs 1 (fused lax.scan training, 100 steps per call):

collocation points / step2k32k131k524k1M
MLP 3×641.0×1.7×4.7×7.0×7.4× (93%)
MLP 4×2561.5×4.0×6.2×7.3× (91%)–

Weak scaling at 131k points per GPU: 98% / 97% / 94% efficiency on 2 / 4 / 8 GPUs.

Two honest caveats, which the revision reports:

  1. The per-epoch jax.jit loop scales poorly. This is the paper's default. Per-step host work does not parallelise: batch indexing and gathering takes 5–7 ms per epoch against a 0.9 ms compiled step at 2k points. Even at 262k points, 8 GPUs give only 1.3× (3×64 net) and 2.9× (4×256 net). Moving sampling inside the compiled step removes this: 8 GPUs then give 6.9× (3×64) and 6.2× (4×256) over the current single-GPU loop, and a single GPU alone becomes 8.5× faster at small batches. We will make this the default training path.
  2. Multi-GPU also makes large problems feasible. On 2-D lid-driven Navier–Stokes, batches of 512k points (and 128k for a wider 4×256 network) exceed one 40 GB GPU but train on 2–8 GPUs. There, sampling inside the compiled step raises 8-GPU speedup from 3.1× to 5.6×.

W2. GPU memory. We agree memory is a first-class metric for a framework paper. We now report XLA's peak device allocation (peak_bytes_in_use, preallocation disabled, A100-40GB) for every benchmark:

BurgersWaveHelmholtzSteady HeatODEPipe FlowRampToro 3Ramp NS
105 MiB164164164801352374*149158

*Ramp's RAR-D step scores a 5× candidate pool.

Under data parallelism, the batch-dependent memory is split across devices: peak per GPU at 1M collocation points per step on 8 GPUs:

GPUs1248
GPU 010.3 GB5.93.62.8
GPUs 1…D−1–4.72.20.99

The non-primary devices scale as about 1/D1/D. GPU 0 holds extra because each batch is assembled there before sharding; sampling inside the compiled step (W1, caveat 1) removes this.

Cross-framework, A100, peak MiB (Burgers / Helmholtz): underPINN 263 / 257, jinns 268 / 257, DeepXDE 270 / 260, PhysicsNeMo 294 / 230. All are within 15%. Two problems only.

W3. PINNacle. We ran six PINNacle tasks under PINNacle's vanilla-PINN protocol (5×100 tanh, Adam 1e-3, 20,000 full-batch iterations, 8192 domain / 2048 boundary points, L2RE over all reference points), with PDEs, boundary conditions and reference data transcribed from their code (3 seeds, mean ± sd):

taskunderPINNPINNacle vanilla PINN
Burgers 1d-C0.0163 ± 0.00290.0145
Poisson 2d-C0.609 ± 0.0020.694
Heat 2d-VC1.15 ± 0.031.01
Heat 2d-MS0.091 ± 0.0430.062
Wave 1d-C0.538 ± 0.0150.588
NS 2d-C0.047 ± 0.0060.047

Every task is within about 15% of the published mean or within seed spread. This includes the tasks where vanilla PINN fails (L2RE above 0.5 on Poisson 2d-C, Heat 2d-VC and Wave 1d-C): we reproduce the failures rather than beat them, as a faithful framework should. Remaining differences: initializer (LeCun vs. Glorot) and point sampling (pseudo-random vs. Hammersley). Training takes 50–295 s per 20,000 iterations on an A100 (peak memory 257–1,559 MiB), against 284–1,160 s in PINNacle's Table 12. That table does not state its hardware, so this is indicative, not matched.

Beyond the requested items, we also integrated five recent architectures through the network factory alone (General Response §3), and added a training-diagnostics module (General Response §2) that runs unchanged under data parallelism.

We would be glad to clarify any of these results further.

Thank you for conducting and reporting new experiments. I will maintain my scores because of unimpressive performance of underPINN on PINNacle (v/s vanilla PINN). I also think that the new results should be reported more completely: GPU memory is added but not compared against the baselines, new baselines are added (in response to 7We9) but not compared against underPINN.

Thank you for reading the new results. Our first reply did not put the comparisons in one place. Here they are.

1. PINNacle. underPINN trains a vanilla PINN, and PINNacle's baseline is the same algorithm. The aim was to check that underPINN reproduces it, not to beat it. We do not claim higher accuracy on PINNacle. Six tasks, 3 seeds, relative L2 error:

TaskunderPINNPINNacle vanilla PINN
Burgers 1d-C0.0163 ± 0.00290.0145
Poisson 2d-C0.609 ± 0.0020.694
Heat 2d-VC1.15 ± 0.031.01
Heat 2d-MS0.091 ± 0.0430.062
Wave 1d-C0.538 ± 0.0150.588
NS 2d-C0.047 ± 0.0060.047

Two are better, one is equal, three are worse by 12–47%. The Heat 2d-MS gap is inside the seed spread. The failure cases (Poisson, Heat VC, Wave) fail in both. Training takes 50–295 s per 20,000 iterations. PINNacle reports 284–1,160 s, but states no hardware, so this is indicative only.

2. GPU memory against the baselines. A100, peak MiB, Burgers / Helmholtz (the peak includes the error evaluation, for all frameworks):

underPINNjinnsDeepXDEPhysicsNeMo
263 / 257268 / 257270 / 260294 / 230

On Burgers underPINN is the lowest, by a small margin. On Helmholtz PhysicsNeMo is the lowest.

3. New baselines against underPINN. Same network, points, loss weights, initialisation and optimiser; 20,000 epochs, 3 seeds, A100.

Burgers ms/epochTo 1% errorHelmholtz ms/epochTo 2% error
DeepXDE (JAX)1.5513.2 s1.286.4 s
underPINN1.8017.2 s1.246.8 s
PhysicsNeMo (default JIT)3.1027.1 s2.7411.6 s
jinns2.9226.2 s2.239.4 s

On Burgers, DeepXDE is 1.2× faster than underPINN per epoch and reaches 1% error 1.3× sooner; underPINN is 1.5–1.7× faster than jinns and PhysicsNeMo. On Helmholtz, underPINN and DeepXDE are level. Plain PyTorch on Burgers takes 5.78 ms/epoch (eager), 7.69 (TorchScript) and 12.82 (torch.compile), against 1.8 for underPINN. These are two problems, not the full suite. The architecture baselines (PirateNet, PINNsFormer, PINNMamba, PIKAN) are compared with underPINN's MLP at equal epochs and at equal wall-clock in the General Response.

4. Diagnostics: understanding the result, not only getting it. A loss curve says that a PINN trained. It does not say why it behaved as it did. Most frameworks stop at the result. underPINN adds diagnostics that explain it. They answer:

  • Which loss term limits accuracy?
  • Is the loss landscape sharp or ill-conditioned?
  • Does the input representation suit the physics?
  • Is the output layer converged?
  • Where does the remaining error live?

The input check shows what the network can and cannot represent of its input. This explains why an output is wrong, and what to change. The diagnostics work with any solver, optimiser or network. They are tested on problems with known answers. To our knowledge, no other open-source PINN framework offers this. A research framework should help people understand a result, not only produce it.

We will add the shock–boundary-layer interaction (SBLI) problem to the revision. We will train it with different input representations: a wall-distance coordinate for the boundary layer, a shock-front coordinate for the shock, and Fourier features for spectral bias. For each, we will show whether training gets better or worse. We will use the diagnostics to explain why, and to show how to improve it.

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

The paper presents underPINN, a modular JAX framework combining compiled PINN training with existing architectures, domain decomposition, and adaptive sampling methods. It compares speed and accuracy across several frameworks and studies when selected training strategies help or fail.

Critical strengths

The unified implementation could be useful for experimenting with different PINN components. The cross-framework audits and multi-seed experiments identify practical comparison pitfalls. Reporting negative results also makes the evaluation informative.

Critical weaknesses

The contribution beyond integrating existing methods is limited. Much of the large speedup comes from compiled versus eager execution; advantages over other compiled JAX frameworks are smaller. Faster epochs do not establish faster solutions at comparable accuracy. Several baselines achieve lower errors, while hardware-related compilation failures further limit the generality of the efficiency claims.

Questions for authors

How do the frameworks compare in total time to reach a common error threshold, with comparable tuning budgets? Do the speed advantages persist on hardware where the baseline compilation paths work fully?

1 comment

Thank you for the careful reading and for recognising the value of the cross-framework audits, multi-seed experiments and negative results. We address the weaknesses and both questions.

W1. Contribution beyond integrating existing methods. We agree the submission foregrounded "a framework" more than what is new. To our knowledge, the following go beyond integration (General Response §1):

  • A matched audit of five PINN frameworks. It exposes hidden defaults that silently invalidate comparisons (PhysicsNeMo weight normalization: 69× on Helmholtz; jinns time renormalization) and a seed-identical ablation reversal caused by GPU non-determinism.
  • A structural account of PINN speedups. Speedup tracks the dispatch-to-compute ratio, and torch.compile cannot capture the PINN double-backward.
  • A five-seed, six-problem adaptive-collocation ablation. RAD helps only on localized, uncapped features.
  • Data-free Toro Test 3 and Mach-3 viscous SBLI benchmarks.
  • New since submission: failure diagnostics, and architecture gains that vanish at equal wall-clock against a well-trained baseline.

W2. Much of the speedup is compiled vs. eager. Agreed, and we now say so in the abstract. The framework-level claim becomes the compiled-vs-compiled margin: 1.07–2.36× over jinns and 1.12–2.06× over DeepXDE's JAX backend (Table 2, measured on GB10; see W3). The 1.03–17.4× eager numbers are presented as an analysis of when compilation matters: speedup tracks the dispatch-to-compute ratio (Sec. 3.2), not as an advantage of underPINN specifically.

W3 / Q1. Faster epochs vs. faster solutions; time to a common error threshold. For a fixed problem, network and optimizer, frameworks execute the same algorithm, so accuracy per step is set by configuration choices (initializer, collocation sampling), not by the execution engine. Appendix A.10 isolates these: jinns' initializer accounts for about half of its Steady Heat advantage, and its minibatch cycling accounts for none. Time-to-accuracy then follows from throughput unless those choices differ. We now measure it directly:

Same network, points, loss weights, Glorot-normal init and Adam 1e-3 with cosine decay; 20,000 epochs, 3 seeds, A100. Time excludes compilation and evaluation. No per-framework learning-rate tuning.

FrameworkBurgers ms/epTo 1% errorHelmholtz ms/epTo 2% error
DeepXDE (JAX)1.5513.2 s1.286.4 s
underPINN1.8017.2 s1.246.8 s
PhysicsNeMo (default JIT)3.1027.1 s2.7411.6 s
jinns2.9226.2 s2.239.4 s

All reach similar final error (0.2–0.9%). On Burgers, DeepXDE is fastest, 1.3× faster to target than underPINN, which is 1.5× faster than jinns and PhysicsNeMo. On Helmholtz, underPINN and DeepXDE are level and 1.4–1.7× faster than jinns and PhysicsNeMo. Table 2 was measured on a GB10 GPU and these runs are on A100, so the ordering can differ.

W4. Several baselines reach lower errors. On each row where a baseline is lower, the difference traces to a configuration choice, not to execution:

  • Steady Heat: jinns' initializer accounts for about half of its advantage (A.10, Table 10).
  • DeepXDE: uses a fixed collocation set; it cannot minibatch.
  • ODE Harmonic: our default learning rate; at 1e-2 it converges (Sec. 3.9, Table 7).
  • Burgers, Heat Unsteady: intervals overlap.

Each is a portable setting, not a framework property, which is the paper's thesis. In the revision we add the "same-initializer" arm to Table 2 so the comparison is like-for-like.

W5 / Q2. Do the speed advantages persist where baselines compile fully? The GB10 (sm_121) results ran PhysicsNeMo without its default nvFuser JIT, and torch.compile fell back to aot_eager on two of three problems. We reran on NVIDIA A100 (sm_80), where every compile path works: TorchScript, and torch.compile with the Inductor backend. Burgers (Table 8 configuration, 5,000 epochs, 3 seeds):

A100, Burgersms/epochJAX jit speedup
JAX jit (underPINN default)2.92 ± 0.00–
PyTorch eager5.78 ± 0.041.98×
TorchScript7.69 ± 0.462.63×
torch.compile (Inductor)12.82 ± 0.084.39×

So with plain PyTorch the gap does not close; it widens relative to GB10, where it was 1.03×. torch.compile cannot capture the standard PINN double-backward (autograd.grad(..., create_graph=True)), so the compiled baseline must use the torch.func formulation, which is slower than eager to begin with (16.2 ms/epoch uncompiled).

PhysicsNeMo with its defaults (TorchScript activation, CUDA graphs; torch 2.5 has no nvFuser) takes 3.10 ms/epoch, 1.7× slower than underPINN (1.8, W3). The JAX row above uses an older residual; the library's current one takes 1.8 ms. Without CUDA graphs: 6.0–6.4 ms. Pipe Flow and Ramp NS were not run on A100.

Comments on the paper

1 comment

We thank the reviewers for careful and constructive reviews. Three concerns are shared: (i) the contribution beyond integrating existing methods, (ii) whether the speed results reflect fully optimized baselines and faster solutions, and (iii) scope: multi-GPU, memory, standard benchmarks, modern architectures. We address each below and per reviewer.

1. What is new. We agree the submission foregrounded "a framework" and under-stated what is new. To our knowledge the following are new:

  1. A matched audit of PINN frameworks. PhysicsNeMo, jinns, DeepXDE-JAX, PINNs-JAX and PyTorch, configured to the same physics, network and collocation. It exposes hidden defaults that silently invalidate "same architecture" comparisons: PhysicsNeMo's weight normalization (a 69× accuracy effect on Helmholtz), and jinns' time renormalization and 2-D-only convective operator. It also shows a single-seed ablation reversing under identical seed and code through GPU non-determinism. We are not aware of earlier PINN framework comparisons that audit hidden defaults.
  2. A structural account of PINN speedups. Speedup tracks the dispatch-to-compute ratio, not problem complexity. torch.compile cannot capture the PINN double-backward, so the strongest compiled PyTorch baseline must use a slower formulation; confirmed on A100 (§3).
  3. A five-seed, six-problem adaptive-collocation ablation. RAD helps only where a localized, uncapped feature exists.
  4. Data-free compressible benchmarks beyond the Sod/Lax problems usual in the PINN shock literature: Toro Test 3 (a 10510^5 pressure ratio) and a Mach-3 viscous shock/boundary-layer interaction.
  5. New since submission: failure diagnostics (§2).
  6. New since submission: evidence that architecture gains are often baseline artefacts. Under equal wall-clock time and a standard training recipe applied to every model (causal weighting, gradient-norm balancing, an L-BFGS finish), PirateNet's Allen–Cahn advantage over an MLP falls from 4.9× to 0.9×. This is the same confound as item 1, at the level of architectures.

We also revise the framing. The headline speed claim becomes the compiled-vs-compiled margin (1.07–2.36× over jinns and DeepXDE-JAX), with the eager-PyTorch numbers presented as the item-2 analysis. Revision-history narration moves to a reproducibility appendix.

2. Diagnostics that explain failures. We added a module that, to our knowledge, no open-source PINN library provides. It works for any network and loss, with no change to the training engine:

  • per-term gradient conflict and per-term NTK, with suggested weights;
  • causality profiles that detect collapsed solutions (error rising along tt while the residual falls);
  • point-singularity localisation;
  • resolved spectral bandwidth;
  • automatic findings with evidence and an action.

It is checked against exact identities (48 tests). It reports the collapsed-solution signature on a failing convection run, only informational notes on well-trained models, and it located a real defect in our own PINNMamba implementation: a normalisation-layer singularity at the domain centre.

3. New experiments.

ConcernNew result
Modern architecturesPirateNet, PINNsFormer, PINNMamba and two PIKAN variants added through the network factory only, with zero changes to solvers or the training loop; 5 PDEs × 3 seeds, parameter-matched, at equal epochs and equal wall-clock.
Multi-GPUExact-gradient data parallelism on 8× A100: up to 7.4× (93% efficiency); 94% weak-scaling efficiency.
Memory80–164 MiB on eight of nine problems; per-GPU memory 10.3 GB → 0.99 GB on 8 GPUs. Cross-framework (Burgers, Helmholtz): 223–294 MiB; no framework is clearly lower
Fully compiled baselinesA100, every compile path working: underPINN 1.98× faster than eager PyTorch and 4.39× faster than torch.compile (Inductor) on Burgers; PhysicsNeMo with its defaults is 1.7× slower than underPINN
Time-to-accuracyMatched Burgers and Helmholtz, 3 seeds. Burgers: DeepXDE is fastest (1.3× over underPINN), which is 1.5× over jinns and PhysicsNeMo. Helmholtz: underPINN and DeepXDE level, 1.4–1.7× over jinns and PhysicsNeMo. Two problems only
Standard benchmarkSix PINNacle tasks, PINNacle's protocol, 3 seeds: every task within about 15% of the published vanilla-PINN L2RE or within seed spread, including its failure cases

We are happy to run further checks during the discussion.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.