NeuralOperator
New1. Overview
NeuralOperator is the reference PyTorch implementation of Fourier Neural Operators and related architectures. It is a library, not a solver: it learns a map from an input function, such as a permeability field or an initial condition, to an output function, such as a pressure or temperature field. That contract is narrower than the phrase "AI for PDE" suggests, and most disappointment with the library comes from asking it to answer a question it was never designed for. This entry explains what the library actually provides, how to configure it, which assumptions its components encode, and how to evaluate a trained model without deceiving yourself with a single relative error number.
The intended reader has paired input and output fields from a numerical solver, a compute budget, and a requirement to defend the result. A second audience is the engineer reviewing a proposal that claims an operator model will replace a CFD solver; this entry supplies the questions to ask about data provenance, resolution transfer and out-of-distribution behaviour. The companion neural operator selection guide compares architecture families, the classical solver cost guide handles amortisation, and the PINN landscape guide covers residual-based training. Here the focus stays on one library and the concrete API choices it exposes.
What this guide does not do: it does not reproduce a benchmark table from a paper, does not claim a universal speed-up, and does not recommend a single architecture for all physics. It also does not cover source-level extension of the library. All statements about the API were checked against the project documentation and README on 9 November 2026; where the evidence is a project's own description rather than an independent measurement, Section 9 labels it as such. Version and source details, including the distinction between the 2020 FNO preprint year and the library release, are recorded there.
2. How It Works
A conventional network maps a fixed-size vector to a fixed-size vector. An operator model targets a map between function spaces: coefficients, forcing, boundary data or an initial condition go in, and a solution field comes out. The Fourier layer implements a global convolution by transforming the hidden representation, multiplying the retained low-frequency modes by learned complex weights, and transforming back. Because those weights are indexed by Fourier mode rather than by grid position, the parameter count does not scale with the number of grid points. That is the architectural property behind the library's claim of resolution invariance.
The resolution of that claim matters. The weights can be applied on a different grid, but a network trained on one discretisation carries spectral biases from that discretisation. A 2026 study on the limits of resolution equivariance reports that direct inference at a finer grid is not reliably beneficial on Darcy flow and can be worse than running at the training resolution and upsampling by Fourier zero-padding; it attributes part of the fragility to aliasing from nonlinear activations and to the concentration of intermediate representations in low frequencies. In other words, an API that accepts a differently shaped array is not evidence that the physics transfers. The library's own quickstart uses FNO(n_modes=(16, 16), hidden_channels=64, in_channels=2, out_channels=1); the n_modes tuple is a bandwidth choice, and the truncated high frequencies are where sharp gradients and discontinuities live.
Three components complete the architecture. A lifting channel projection maps the input to a hidden width, a stack of Fourier layers mixes global information, and a projection head returns the output field; each layer also contains a local pointwise path and a residual connection. Tensorised variants such as TFNO apply a Tucker factorisation to the spectral weights. The documented quickstart constructs TFNO(..., factorization='tucker', implementation='factorized', rank=0.1) and states that the Fourier layers then hold roughly ten percent of the parameters of an equivalent dense FNO. That is a parameter-count statement, not a wall-clock guarantee: the factorised contraction is a different kernel, and its speed depends on tensor shapes and hardware. The FNO paper and the neural operator framework paper listed in Section 10 give the underlying formulation.
3. Scope and Assumptions
The library assumes supervised paired fields. You need a corpus of input functions and corresponding solution fields, normally generated by a numerical solver such as OpenFOAM or FEniCS. If you only have sparse observations, unpaired snapshots, or a single trajectory with no known input function, the operator-learning contract does not apply directly; a physics-informed formulation or a classical data-assimilation route may be a better fit. The PINN landscape guide describes that alternative contract in detail.
The second assumption is a regular grid for the vanilla FNO path. The FFT in a Fourier layer is a discrete transform on a uniform lattice with an implicit periodic extension. Non-periodic boundaries, irregular meshes and changing geometry require explicit handling: domain padding, Fourier continuation, a coordinate deformation as in Geo-FNO, or a graph-based operator. A 2025 practical guide aligned with the library's 2.0.0 generation collects these options and recommends keeping n_modes below half the grid resolution for super-resolution work to avoid aliasing. Irregular finite-volume output must be interpolated onto a regular lattice before training, and that interpolation is a modelling step with its own error budget, not a lossless format conversion.
The third assumption concerns the distribution. The library learns the map seen in the corpus. Coefficients drawn from a new range, a new boundary-condition type, a new topology or a new flow regime are structural extrapolation, and should be tested separately from ordinary held-out parameter generalisation. The neural operator selection guide keeps resolution transfer, parameter generalisation and structural extrapolation as three distinct tests. Finally, the library is PyTorch-specific; teams whose training stack is JAX-based should expect integration work. MIT licensing permits commercial use and modification subject to notice retention, which is a legal question for your own review rather than a technical guarantee in this guide.
4. Getting Started
Installation is documented as pip install neuraloperator from PyPI, or a local editable install with pip install -e . plus the requirements file for development. The import path is neuralop. A minimal first run uses the bundled Darcy-flow example: load_darcy_flow_small(n_train=1000, batch_size=32, ...) returns a training loader, test loaders at declared test resolutions, and a data processor that handles the transforms the model expects. Keeping that processor in the loop matters, because normalisation and coordinate conventions applied at training time must be applied identically at inference; a common failure is a model that performs well in a notebook and poorly in a service because the transform was dropped.
Model construction follows the quickstart pattern. FNO takes n_modes, hidden_channels, in_channels and out_channels; TFNO adds factorisation arguments. The Trainer class in neuralop.training wraps the standard training loop with n_epochs, a data processor, an optimizer, a scheduler, a training loss and evaluation losses. Checkpoints are written with model.save_checkpoint(save_folder, save_name) and restored with FNO.from_checkpoint(...). For a production corpus, pin the library version, the PyTorch version and the random seed, and record them next to the checkpoint. The FNO tutorial and the practical neural operator tutorial on this site collect the surrounding learning material.
Before scaling up, run a small overfitting study on a subset of the corpus. If the model cannot drive training error near zero on a few hundred samples, the issue is likely the data contract or the transforms rather than capacity. Then widen the test protocol: evaluate at the training resolution, at a finer resolution with a freshly computed reference solution, and on held-out coefficients drawn from outside the nominal range. Record per-field errors, conserved integrals and boundary fluxes. The neural operators collection and PDEBench are useful starting points for protocol design. The classical solver cost guide explains why the cost of producing this test set belongs in the project budget.
5. Comparison with Alternatives
The most useful comparison is by contract rather than by benchmark rank. DeepONet uses a branch network for sensor values and a trunk network for query coordinates, so it naturally handles scattered sensors and irregular query points; it does not require a uniform grid, but its sensor layout defines what the model has seen. PhysicsNeMo targets physics-informed training, where a PDE residual provides supervision and labelled fields may be scarce; that is a different data regime from the paired-corpus requirement here. Poseidon represents foundation-style pretraining for PDE surrogates, trading a large pretraining corpus for wider coverage across tasks.
Within the library itself, dense FNO and tensorised TFNO differ in parameterisation rather than in the function-space contract. The documented ten-percent parameter figure for a Tucker-factorised configuration is a memory and capacity statement; measured throughput depends on the contraction shapes. Beyond the Fourier family, geometry-aware and graph-based operators exist for irregular domains, and physics-informed operator variants add a residual term to the loss. The neural operator selection guide organises these into four architecture families and a decision tree; this entry stays with what the library ships and documents.
A classical reduced-order model is also a legitimate comparator. Proper orthogonal decomposition with a coefficient interpolant can be cheaper to train, easier to audit, and adequate when the solution manifold is low-dimensional. A classical solver is the reference for correctness, not a competitor on inference latency. Comparisons should therefore state the deliverable: a single certified solve, an interactive design sweep, or an inverse problem with gradients. A library that wins on a fixed GPU-forward-pass benchmark may lose on a project where corpus generation and validation dominate, which is exactly the accounting in the cost boundary guide.
6. Benchmarks and Evidence
The library bundles a Darcy-flow example, and the original FNO paper reports Burgers, Darcy and two-dimensional Navier-Stokes experiments. Those results established that a spectral operator can be competitive with CNN and U-Net baselines on parametric PDE families. They are not a speed-up guarantee for your case, and they do not measure the cost of generating the corpus. Quoting a relative L2 error from a paper without reproducing the data split, the resolution and the normalisation makes the number meaningless.
A sound evaluation protocol has four layers. First, in-distribution error on held-out coefficients, reported per field and in physical units. Second, resolution transfer: keep the physical input fixed, change the grid, recompute a trusted reference with the solver, and compare in physical coordinates. Third, stress tests: perturb the input spectrum, shift coefficients outside the training range, and roll the model forward autoregressively to observe error accumulation. Fourth, physical consistency: conserved integrals, boundary fluxes and any quantity of interest that the deliverable actually uses. Variance-reduced or binned spectral errors are more informative than a single aggregate, because a small global error can hide a smeared shock or a missed peak.
Recent evidence specifically cautions against assuming zero-shot resolution equivariance. The 2026 study cited earlier found direct fine-grid inference not reliably beneficial on Darcy flow and sometimes worse than a low-resolution prediction upsampled by Fourier zero-padding, with layerwise spectra showing energy concentrated in low frequencies and high-frequency content produced late in the decoder. A 2025 practical guide recommends multi-resolution training, careful n_modes selection relative to the Nyquist limit, and small-scale overfitting diagnostics. Treat both as protocol guidance, not as a leaderboard. Any number in a proposal should come from a local run with the corpus, checkpoint, version string and hardware recorded, following the same discipline used for the battery thermal case and PDEBench.
7. Role in Physics-AI Workflows
In a production pipeline the library sits between a solver and a consumer. The solver produces paired fields; the library trains the operator; the consumer queries it for design sweeps, uncertainty loops or inverse problems. The value of the operator is concentrated in repeated queries inside a narrow distribution. If the same parameter set is queried once, training cost dominates. If it is queried tens of thousands of times, the amortisation can work, subject to the four ledgers in the cost boundary guide. Writing down the expected query count before training is the cheapest way to avoid an unrecoverable investment.
Data preparation is where most engineering effort lands. Input functions must be represented consistently, output fields must be aligned to a common lattice, and any interpolation from an unstructured OpenFOAM mesh must be documented. The data processor returned by the bundled dataset loader should be treated as part of the model artefact. Where the operator is used as a preconditioner, a warm start or a proposal distribution inside a hybrid solver, the handoff needs a measurable guard: a residual check, a conservation check, or an out-of-distribution score that routes the query back to the solver. The classical solver cost guide describes these hybrid patterns.
The library also fits into a broader verification chain. A PINN can supply residual-based corrections when labels are scarce; a foundation-style model such as Poseidon can provide a pretrained starting point; a graph-based operator can take over when geometry becomes irregular. None of these removes the need for an independent reference solve on held-out configurations. The physics-AI learning path places these roles in sequence. What the reference implementation uniquely supplies is a stable, inspectable baseline: a documented architecture, a reproducible training loop and a checkpoint format that another team can load.
8. Limitations and Failure Modes
Spectral truncation is a modelling assumption. Retaining a small number of Fourier modes discards high-frequency content, so sharp gradients, shocks, discontinuities and thin boundary layers are smoothed. Increasing n_modes raises capacity and memory cost, and does not by itself fix a truncation bias learned from single-resolution data. A model can show a low relative L2 error while smearing the peak that a thermal or structural design actually cares about; per-field and peak-aware metrics are mandatory whenever the quantity of interest is an extremum.
Autoregressive rollout accumulates error. If the operator is applied step by step, a small one-step bias becomes a distribution shift at the next step, and long-horizon trajectories can drift or become physically implausible. Boundary conditions and conservation laws are not enforced exactly by a data-driven loss, so mass or energy drift can coexist with a good-looking field. Out-of-distribution failure is often silent: predictions remain smooth and bounded while being wrong. A resolution change, a new geometry, a shifted coefficient range or a different boundary-condition type can all trigger it without any runtime error.
There are practical limits too. Training a large operator needs GPU memory proportional to the retained modes, hidden width and batch size; a Tucker-factorised model reduces parameters but may not reduce wall-clock time on a given device. The library is PyTorch-specific and does not by itself provide uncertainty quantification, certification evidence or an audit trail. A vanilla FNO path expects regular, periodic-friendly grids, and the interpolation needed to get there can dominate the error budget. When the deliverable requires certified accuracy, a classical solver remains the reference; the neural operator selection guide catalogues the stress tests that should precede any deployment decision, and the cost boundary guide explains when deferral back to the solver is the correct design.
9. Version and Source Notes
Record 1: the project documentation describes neuraloperator as a comprehensive PyTorch library and the official implementation of Fourier Neural Operators, part of the PyTorch Ecosystem, with resolution-invariant models. Its quickstart shows FNO, TFNO, load_darcy_flow_small, Trainer and the checkpoint API quoted in this guide. These are project-authored capability statements checked on 16 November 2026, not independent validation of accuracy or speed. Record 2: the documented TFNO configuration with rank=0.1 is stated to use roughly ten percent of the parameters of a dense FNO. That is a parameter-count claim; this guide deliberately does not convert it into a latency claim.
Record 3: a 2025 practical guide on Fourier neural operators describes close alignment with a NeuralOperator 2.0.0 generation of the library, and discusses domain padding, Fourier continuation, n_modes relative to the Nyquist limit, incremental multi-resolution training and physics-informed extensions. That is a secondary source describing a library generation, not a pinned release statement from PyPI. This entry therefore does not assert a current released version number and recommends pinning the installed version in every experiment. Record 4: repository snapshots reported in 2026 show ongoing commits, including conditioning and configuration work in October 2026; that indicates active maintenance but should not be read as a stability guarantee for any specific API.
Record 5: the catalogue year value on this entry is 2020, which is the year of the FNO preprint arXiv:2010.08895, not the release year of the library or of the FNO paper record on this site. Record 6: the MIT licence permits commercial use and modification with notice retention; that is a licence description from the repository, not legal advice. Record 7: the neural operator preprint carries the title "Neural Operator: Learning Maps Between Function Spaces" on arXiv, while the JMLR version adds "With Applications to PDEs" and is paginated 24(89):1-97; the arXiv journal_ref lists pages 4061-4157, which differs from the publisher page, so this guide takes 1-97 from the publisher and keeps the title difference visible in the reference list. All seven records were checked on 16 November 2026 against the project documentation and README, the 2026 resolution-equivariance study arXiv:2606.00677, the 2025 practical guide arXiv:2512.01421, the JMLR volume 24 index and the article page, and the original FNO and neural operator papers. Where public claims disagree, Section 2 and Section 6 state the narrower, testable version and leave the broader claim attributed.
10. References
- NeuralOperator project, "Neural Operators in PyTorch: documentation and quickstart", neuraloperator.github.io (accessed 16 November 2026).
- neuraloperator/neuraloperator, "README: installation, FNO/TFNO constructors, Darcy dataset and Trainer", GitHub repository (accessed 16 November 2026).
- Li Z. et al., "Fourier Neural Operator for Parametric Partial Differential Equations", ICLR 2021, arXiv:2010.08895.
- Kovachki N. et al., "Neural Operator: Learning Maps Between Function Spaces With Applications to PDEs", JMLR 24(89):1-97 (2023); arXiv preprint titled "Neural Operator: Learning Maps Between Function Spaces", arXiv:2108.08481.
- Lu L. et al., "Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators", Nature Machine Intelligence 3 (2021) 218-229.
- Duruisseaux V., Kossaifi J., Anandkumar A., "Fourier Neural Operators Explained: A Practical Perspective", arXiv:2512.01421 (2025).
- Colagrande A. et al., "Limits of Resolution Equivariance in Fourier Neural Operators", arXiv:2606.00677 (2026).
- Li Z. et al., "Physics-Informed Neural Operator for Learning Partial Differential Equations", ACM/IMS Journal of Data Science 1(3) 1-27 (2024), arXiv:2111.03794.
- Takamoto M. et al., "PDEBench: An Extensive Benchmark for Scientific Machine Learning", NeurIPS 2022 Datasets and Benchmarks Track.
- DClaw Research, "Choosing a Neural Operator in 2026" and "The Cost Boundary of Classical Solvers", site guides (9 November 2026).