Neural operators are networks that learn a mapping between functions, such as from a permeability field to a pressure field, rather than between fixed-size arrays. Because of this, a model trained on a coarse simulation grid can in principle be run on a much finer one without retraining. This is called zero-shot super-resolution. That promise has a hidden price. Running a Fourier neural operator directly on a fine grid costs far more compute than running it on the coarse one. It also often gives worse answers. Limits of Resolution Equivariance in Fourier Neural Operators shows why: pointwise nonlinearities fold high-frequency energy back into low frequencies, an effect known as aliasing. In that work, evaluating at the coarse training grid and then upsampling by Fourier zero-padding matched or beat direct fine-grid inference on 2D Darcy flow. So the grid an operator is run on is a choice with both accuracy and cost consequences. Today that choice is made by hand, or silently set equal to the output grid.
We propose to make the internal evaluation grid a searched architectural variable. It would sit alongside per-layer Fourier mode counts, channel widths, and an optional anti-aliasing step that applies each nonlinearity on an oversampled grid. All of these would be chosen jointly against latency measured on the deployment hardware. Training happens once, at coarse resolution, in a weight-shared "supernet" whose subnetworks are cut from it. Resolution independence then lets us score every candidate at every grid size without retraining. The question we ask is sharp. On a given device, at a given output resolution, is the best accuracy–latency tradeoff ever achieved by anything other than "small FNO at the coarse grid plus padding"? If so, what does it look like?
Core Claim
Hardware-aware architecture search for neural operators needs two ingredients that no existing method combines. The first is a search space in which the evaluation resolution $r$, with $s \le r \le S$ for training resolution $s$ and target resolution $S$, is a decision variable. The second is a latency model that is a function of $r$ rather than a lookup table frozen at one input shape. Our claim is that, with both in place, the accuracy–latency Pareto front contains configurations that strictly dominate the Low+pad baseline on at least one realistic device–resolution pair. The candidates are intermediate $r$ with few modes and anti-aliased activations. Our second claim is that the optimal $r$ differs between a desktop GPU and an edge module, much as HAT found that the best transformer shape differs between CPUs and GPUs. The obvious version of this project would be "add a latency term to neural-operator NAS." That version would be beaten by Low+pad, because Low+pad costs almost nothing. Our version contains Low+pad as one point in the search space ($r = s$, no anti-aliasing), so the search can only match or improve on it. The scientific content is whether it improves.
Research Program
The base model family is the Fourier neural operator of Fourier Neural Operator for Parametric Partial Differential Equations. Each layer transforms its input to frequency space with an FFT, keeps the lowest $k$ modes, multiplies them by learned weights, transforms back, and adds a pointwise linear path before a nonlinearity. The searched choices are as follows. Per-layer mode counts $k_\ell$ are drawn from a small grid. Channel width is restricted to multiples that align with GPU matrix-core tiles, following The Case for Co-Designing Model Architectures with Hardware. Depth is searched as well. A per-layer anti-aliasing flag determines whether the nonlinearity is applied after zero-padding the spectrum to $2\times$ the grid and then truncating back, which directly targets the mechanism identified in the Limits paper. Finally, a global evaluation resolution $r$ sets the grid on which the network runs, after which the output is Fourier-padded to $S$.
Search cost is held down in one way. We train a single weight-shared supernet at the coarse resolution $s$, with randomly sampled subnetworks per step (mode prefixes and channel prefixes). Mode truncation is naturally nested, which limits the interference between candidates that hurts continuous relaxations such as Differentiable Neural Network Architecture Search. Scoring a candidate at grid $r$ then needs only forward passes. This contrasts with FWNO, whose GFlowNet sampler, a generative policy that proposes architectures with probability proportional to a reward, uses a reward of $e^{-\text{Loss}_{\text{val}}}$ only. That reward requires training wavelet-operator candidates and ignores hardware entirely. FWNO is the closest prior work and supplies evidence that layer-heterogeneous operator architectures help. We differ in three ways: we add cost, we treat resolution as a variable, and we amortize training.
The latency model replaces the fixed-shape lookup tables of MoGA and the fixed-shape predictors used in HAT. For each layer type we fit
$$ t_\ell(r) = a_\ell \, r^d \log r^d + b_\ell \, r^d c_\ell + e_\ell, $$
where $t_\ell(r)$ is measured latency at grid side $r$ in $d$ spatial dimensions, $c_\ell$ is channel width, and $a_\ell, b_\ell, e_\ell$ are per-device constants. The first term is the FFT cost, the second is the pointwise and channel-mixing cost, and the third is fixed launch overhead. The form follows the $O(n \log n)$ FFT scaling stated for FNO. It is calibrated from a handful of measured grid sizes per device and validated on held-out sizes. Whole-network latency is the sum over layers plus padding cost. We will also report where the model fails, for example cache-size cliffs on the edge module. The search itself is plain multi-objective evolutionary search over the supernet: it minimizes fine-grid relative $L_2$ error and predicted latency, with final Pareto points re-measured on device.
One honest complication concerns model selection. Choosing among candidates by fine-grid error requires some fine-resolution ground truth. We use a small held-out fine set of 50 samples for selection only, never for training. We also test a fully coarse alternative: selection by agreement between a candidate's predictions at $r$ and at $2r$, which needs no fine labels.
Baselines
The naive reference point is the hand-designed FNO run directly at the target grid ("Direct-S"), with the standard configuration from the FNO paper. This is what most users do. On a 256×256 Navier–Stokes grid, that paper reports 0.005 seconds per inference, against 2.2 seconds for a pseudo-spectral solver. We re-measure this on our own devices rather than reuse that number.
The strongest competitor is Low+pad from Limits of Resolution Equivariance in Fourier Neural Operators: the same FNO evaluated at the training grid $s$, with output upsampled by Fourier zero-padding. It is the strongest because it is both cheaper and, per that paper, at least as accurate as Direct-S on Darcy flow. No numerical error value for it was found on Lacuna, so we reproduce it under their protocol: train at $s=85$, test at $S=211$, ground truth from the 421×421 data, 1000 training and 200 test samples. Fairness requires that Low+pad receive the same tuning budget as our search. We therefore sweep its width, modes, and depth over the same grid our search uses, measure latency on the same devices, and plot its full Pareto curve rather than a single model. "Beating it" means a configuration with lower relative $L_2$ error at equal or lower measured latency, or lower latency at equal error, beyond seed variance across three seeds, on at least one device–resolution pair.
The strongest search baseline is FWNO. On wavelet operators it reports relative error of 1.44% on 1D Burgers, 1.58% on square-domain Darcy, and 2.35% on 2D Navier–Stokes, against 1.75%, 1.80%, and 3.43% for vanilla WNO. We compare accuracy at matched error and report the GPU-hours each search consumes. Since FWNO has no latency objective, we also place its selected architectures on our measured latency axis.
Two ablations isolate the key ingredients. In the first, we search with $r$ fixed to $S$, which approximates "HW-NAS on operators" without resolution as a variable. In the second, we fix $r = s$ but keep the other knobs, which tests whether gains come from architecture alone. A third ablation removes the anti-aliasing flag.
Why not just…?
Why not just use Low+pad and stop? This is the real threat, and the proposal is built around it. If the search, with Low+pad inside its space, returns $r = s$ with no anti-aliasing at every device and target resolution, the conclusion is that Low+pad is optimal and resolution-free inference is not worth paying for on these benchmarks. That would be a useful negative result, and we would report it as such. Breaking Scale Anchoring argues that padding caps fidelity at coarse-scale content. Our Navier–Stokes experiments, where fine-scale vorticity matters, test whether that cap ever costs enough accuracy to make a larger $r$ worth its latency.
Why not just sweep FNO width and modes by hand and time them? For a small search space, an exhaustive sweep is a fair competitor. We therefore include it as the tuned Low+pad and Direct-S curves above, with equal training budget. The case for the supernet rests on the per-layer, per-resolution space being too large to sweep, as FWNO's finding of layer-specific choices suggests. It also rests on the supernet's subnet rankings matching stand-alone training. We check that matching with rank correlation on 30 independently trained candidates. If the correlation is poor, we fall back to the sweep and keep only the resolution-aware latency model and search space as contributions.
Why not just rank candidates by FLOPs? Capra et al.'s survey documents that FLOPs track latency poorly. FLAME shows the same U-FNO taking 6.2ms on an RTX 4090 and 225ms on a Jetson Orin NX, a gap no FLOP count predicts. FFT memory traffic and launch overhead should matter most at small $r$, exactly where Low+pad lives. We measure the rank correlation between FLOPs and measured latency across candidates and grid sizes on each device, and we rerun the search with FLOPs as the cost to see whether the chosen Pareto points change.
Why not just quantize a trained FNO afterward? Quantization is orthogonal to resolution choice, and we do not make it central. As a secondary check, we apply INT8 post-training quantization in the style of Post training 4-bit quantization to the final Pareto models. We then report whether quantization noise worsens the fine-grid aliasing tail, an interaction that is so far untested.
Proposed Experiments
The benchmarks are 2D Darcy flow under the Limits protocol, with an additional target of $S=421$; 2D Navier–Stokes at 64→256 from the FNO paper; and 1D Burgers. These are extended with two 2D PDEBench tasks from PDEBench, reported with RMSE and Fourier-spectrum error (fRMSE) so that spurious high-frequency tails are visible. The devices are a desktop GPU and a Jetson Orin NX, the latter matching FLAME's 15W edge setting. Latency is batch-1 median over 100 runs. We also report search cost in GPU-hours.
The decisive checks are the following. First, does any searched configuration dominate the tuned Low+pad Pareto curve on Navier–Stokes or Darcy at $S=421$? Second, does the selected $r$ differ between the two devices for the same target? Third, does the resolution-aware latency model predict held-out grid sizes within 10% where a fixed-shape lookup table extrapolated from $s$ does not? Fourth, does selection without fine labels, using self-consistency, recover most of the gain obtained with fine-label selection? A positive answer to the first two questions establishes that the evaluation grid belongs in the search. Negative answers settle, with measured hardware numbers, that padding a small coarse-grid operator is the right default.
References
- Limits of Resolution Equivariance in Fourier Neural Operators
- HAT: Hardware-Aware Transformers for Efficient Natural Language Processing
- Fourier Neural Operator for Parametric Partial Differential Equations
- The Case for Co-Designing Model Architectures with Hardware
- Differentiable Neural Network Architecture Search
- Generative flow induced neural architecture search: Towards discovering optimal architecture in wavelet neural operator
- MoGA: Searching Beyond Mobilenetv3
- Breaking Scale Anchoring: Frequency Representation Learning for Accurate High-Resolution Inference from Low-Resolution Training
- Hardware and Software Optimizations for Accelerating Deep Neural Networks: Survey of Current Trends, Challenges, and the Road Ahead
- FLAME: Physics-Guided Neural Operators for Onboard Satellite Methane Detection in Hyperspectral Imagery
- Post training 4-bit quantization of convolutional networks for rapid-deployment
- PDEBench: An Extensive Benchmark for Scientific Machine Learning