WorksPhysics and Astronomy
IANN: A Unified Framework for Equivariant InterAtomic Neural Networks with User-Friendly Implementation
Abstract
Machine-learning interatomic potentials (MLIPs) now approach density functional theory (DFT) accuracy at a fraction of its cost, but the practical benefit is limited by software fragmentation: each state-of-the-art architecture is released as a separate codebase, with its own data format, configuration system, training loop and molecular-dynamics interface. Comparing two architectures on the same dataset, or moving a trained model into a production simulation, therefore requires substantial re-engineering. We introduce IANN (InterAtomic Neural Network), an open-source PyTorch framework that reimplements equivariant graph neural networks - PaiNN, NequIP, MACE, Allegro, EquiformerV2, EquiformerV3 and UMA - behind a unified data object, a unified trainer and a single deployment route, so that the architecture is a one-word change in a configuration dictionary. Forces, stresses and virials are obtained for every architecture from one analytic differentiation of the energy with respect to the edge vectors of the atomic graph, exact under periodic boundary conditions. Distributed training is configured automatically from the SLURM, PBS or MPI environment, so the same script runs unchanged from a workstation to a multi-node GPU allocation. Self-describing checkpoints serve directly as ASE calculators, as ensembles reporting uncertainties, or as TorchScript models run inside LAMMPS through bundled C++ pair styles with single- and multi-GPU inference. Trained on a common dataset of millions of structures, the architectures can be compared under identical conditions. We further release PaiNN foundation models trained on 41.9 million curated DFT structures from MPtrj, Alexandria, OMat24, MatPES, OC20, OC22, OC25, MPr2SCAN and MatPESr2SCAN, spanning the PBE, RPBE and r2SCAN functionals. Additionally, IANN provides an agent interface to facilitate integration with autonomous agents.
Manuscript.pdf
training is configured automatically from the SLURM, PBS, or MPI environment, so the same training script runs unchanged in various computing environments, such as a multi-GPU workstation and a multi-GPU/node supercomputer. Trained model checkpoints are self-describing and can be directly used as ASE calculators, combined into ensembles that report energies, forces, and their associated uncertainties, or compiled into TorchScript and executed within LAMMPS through bundled C++ pair styles supporting single- and multi-GPU inference and on-the-fly ensemble variance estimation. We demonstrate the framework by training different architectures on a common dataset with millions of structures, enabling meaningful comparisons through consistent training, graph construction, and evaluation procedures. We further provide PaiNN foundation models trained on 41.9 million curated DFT structures from the open-source MPtrj, Alexandria, OMat24, MatPES, OC20, OC22, OC25, MPr²SCAN, and MatPESr²SCAN datasets, spanning three exchange-correlation functionals (PBE, RPBE, and r²SCAN). Additionally, IANN provides an agent interface to facilitate integration with autonomous agents. As open-source, MIT-licensed software, IANN provides an accessible and unified platform for developing, benchmarking, and deploying advanced machine-learning interatomic potentials, accelerating their broader application across computational catalysis, energy storage and battery design, molecular therapeutics, and broader materials discovery.
Introduction
Atomistic simulations based on density functional theory (DFT) have become a cornerstone of modern computational materials science and molecular science. By establishing fundamental relationships between atomic structures and physical properties from first principles, DFT enables the prediction and characterization of materials and molecules before their experimental synthesis, transforming materials discovery and design from empirical trial-and-error approaches into rational, knowledge-driven processes. In catalysis, DFT enables the calculations of adsorption energies, reaction free energies, and activation barriers for elementary reaction steps, including the potential dependence in electrocatalytic systems, where the stability, selectivity and activity of the catalyst can be evaluated through thermodynamic and kinetic analyses, including the phase and Pourbaix diagrams, scaling relationships, and volcano plots.[1, 2, 3, 4] In battery materials, formation energies, ion-migration barriers, and interfacial decomposition energies encode key factors governing capacity, rate capability, and cycle life.[5] [6, 7] In drug discovery, DFT provides insights into conformational energetics, protonation states, and molecular interactions that govern the binding affinity of a candidate molecule for its biological target.[8] Despite its broad applicability, DFT is fundamentally bottlenecked by its high computational cost. This computational burden makes a wide range of applications, including geometry optimization of complex systems, high-throughput screening, large-scale simulations, long-timescale molecular dynamics (MD), and extensive finite-temperature sampling, prohibitively expensive for routine use.
Machine-learning interatomic potentials (MLIPs) were developed to address this bottleneck by learning the potential-energy surface from a finite set of reference calculations and then evaluating it at a cost that is orders of magnitude lower.[9–11] Early high-dimensional neural network potentials described each atomic environment through hand-crafted invariant descriptors,[9] and were then followed by learned invariant representations built on message passing.[12, 13] The current generation is explicitly equivariant: internal features transform under rotation in the same way as the physical tensors they represent, which markedly improves data efficiency and accuracy. Specifically, PaiNN extends scalar node features with Cartesian vector features,[14] while NequIP and Allegro employ spherical harmonics to construct equivariant representations of higher angular orders.[15, 16] MACE combines equivariant message passing with a systematic many-body expansion,[17] whereas the Equiformer family introduces equivariant attention mechanisms, with the latest EquiformerV3, which supports higher-degree spherical harmonics while selectively truncating the interaction orders retained at each degree.[18–20] UMA replaces the tensor product itself: each edge is rotated to align with a common axis, allowing the convolution to be decomposed into independent operations on spherical harmonic features. Its context-conditioning mechanism further enables a single set of model parameters to be shared across multiple domains.[21] Most recently, large-scale models trained on millions of atomic structures, such as UMA[21] and MACE-MP[22], have emerged as foundation models designed for zero-shot prediction or fine-tuning across diverse atomistic systems.
Despite this rapid progress, an important practical challenge remains largely overlooked. Each architecture is typically released as an independent research codebase, with its own conventions for dataset format, configuration systems, training workflows, logging, checkpoint structures, and integration with production MD engines (sometimes even missed). These inconsistencies create substantial practical barriers for researchers seeking to develop machine learning potentials for specific chemical systems. First, an honest comparison between two architectures on one’s own data, with identical data splits, loss weights, optimizer, and stopping criteria, requires reimplementing at least one of them or accepting confounded results. Second, the cost of switching architecture after the fact is high, which biases groups towards whichever model they adopted first. Third, model deployment remains architecture-specific, as integrating a trained potential into LAMMPS[23] typically requires dedicated wrappers and pair-style implementations for each architecture. Fourth, high-performance-computing (HPC) concerns leak into user workflows, as distributed training must be adapted to the launcher and scheduler of each machine. Fifth, extensibility is limited: adding a custom architecture or modifying existing model components often requires substantial changes to the framework-specific code, making it difficult to experiment with new ideas without becoming tied to a particular implementation. In addition, most existing frameworks lack an agent-friendly interface, which would enable autonomous agents to orchestrate model training, inference, and deployment.
IANN (InterAtomic Neural Network) framework addresses these challenges by implementing different neural network architectures as configurable options within a unified PyTorch[24] framework. Its equivariant models use the unified data object and trainer, allowing users to compare inductive biases on their own data while holding the splits, loss weights, optimiser, and stopping criteria fixed. The common interfaces also make it easier to add or modify architectures without rebuilding the surrounding workflow. Beyond training, checkpoints can be directly utilized with an ASE[25] calculator, assembled into ensembles for uncertainty quantification, or compiled to TorchScript for use in LAMMPS[23] through bundled pair styles. Training, inference, and deployment are accessible non-interactively, enabling agent-driven workflows.
Key and specific contributions of this work include:
A unified data representation. All architectures consume and return
AtomsData, a typed, TorchScript-compatible data object built directly, so that datasets, batching and neighbour-list construction are shared across models rather than reimplemented per model.
A unified trainer. One unified dictionary configures the model, loss, optimizer, learning-rate schedule, data splitting and normalisation, early stopping, checkpointing and distributed execution, with roughly ten lines of user code.
Uniform analytic derivatives. Forces, stresses, and virials are obtained for each architecture by differentiating the predicted energy with respect to the graph edge vectors through a single unified implementation.
Launcher-agnostic parallelism. Distributed data-parallel training detects SLURM, PBS, OpenMPI, MPICH/Intel MPI, and MVAPICH2 environments and derives rank, world size, local rank, and rendezvous address automatically; the same script runs unchanged from a workstation to a multi-node GPU allocation.
A production path to LAMMPS. A generic TorchScript wrapper plus C++ pair styles (
pair_style iannandpair_style iann/multi_gpu) run any IANN model inside LAMMPS, and a companion compute style exposes ensemble variance as a thermodynamic quantity for on-the-fly reliability monitoring.
Curated databases at three levels of theory. We curated, standardized, and reorganized public DFT datasets into three functional databases (PBE, RPBE, and r²SCAN), comprising 41.9 million structures that were cleaned of geometric outliers and unreliable labels and packaged in a unified format.[26]
Provided foundation models. Multiple foundation models trained on the curated open-source databases are provided,[27] serving either directly for inference or as starting checkpoints for fine-tuning on a small in-house dataset.
An agent interface. The framework provides an interface with machine-readable output, a Model Context Protocol server, and a set of agent skills, enabling large-language-model (LLM) agents to directly train, inspect, and deploy models.
Theoretical background
Locality and the atomic graph
All models implemented in IANN exploit the locality of atomic interactions through the standard decomposition of the total potential energy into atomic contributions,
where depends only on the local environment of atom within a cutoff radius . This locality assumption is physically motivated by the short-range nature of atomic interactions and enables efficient scaling to large systems. This locality assumption naturally represents each atomic configuration as a graph , where the vertex set corresponds to atoms and the edge set connects atom pairs within the cutoff distance,
where is the cell matrix whose columns define the periodic lattice vectors, and is the integer image shift vector that selects the periodic replica of atom nearest to . Working with edge vectors rather than with absolute positions ensures exact translational invariance by construction and encodes periodicity as a graph property rather than requiring special treatment in the network architecture.
Equivariant message passing
A function acting on graph features is equivariant with respect to rotations if
for every rotation , where is the representation of acting on the output space. Scalars transform with (invariance) and Cartesian vectors with (covariance). Models built on spherical harmonics generalize this to irreducible representations of arbitrary degree , where is the corresponding Wigner -matrix. Equivariance enables the network to represent directional information—such as bond orientations and local symmetry breaking—without learning rotational symmetries from data, thereby improving sample efficiency and generalization.
All architectures in IANN follow the general message-passing framework
where are the node features of atom at layer (in general containing mixed irreducible representations), denotes the neighbors of atom within the cutoff radius, is a radial basis function multiplied by a smooth cutoff envelope, denotes spherical harmonics evaluated on the normalized edge direction , and represents permutation-invariant aggregation—implemented in IANN as a scatter-add operation over edges. The architectures differ in how the message function mixes irreducible representations: PaiNN uses gated products of scalar and vector channels; NequIP, Allegro, and MACE employ tensor products of irreducible representations; the Equiformer family implements equivariant attention mechanisms; UMA utilizes a spherical-channel backbone. Architectures also differ in whether they include explicit many-body expansions, but all share a common interface defined by Eq. (4). After message-passing layers, a readout network maps the invariant () component of to the atomic energy in Eq. (1).
Radial information is encoded using a Bessel function basis with a polynomial cutoff envelope [28]
where is the interatomic distance, and the envelope function and its first derivatives vanish at . This ensures that energies and forces remain continuous as atoms enter or leave the cutoff sphere—a prerequisite for stable molecular dynamics simulations.
Analytic derivatives
Forces are not predicted by a separate network head but obtained as exact analytic derivatives of the predicted energy with respect to atomic positions, which guarantees that the resulting force field is conservative. IANN computes these derivatives with respect to the edge vectors rather than the atomic positions directly,
which follows from and . In the implementation, a single call to automatic differentiation produces for all edges simultaneously, and the two sums in Eq. (6) are evaluated as scatter-add operations onto the center and neighbor indices of each edge (Figure 2c). This route is preferred over differentiating with respect to directly because the periodic image shifts of Eq. (2) are absorbed into the graph construction phase. Consequently, the same code path correctly handles isolated molecules, slab geometries, and fully periodic bulk systems without modification. The virial tensor and stress tensor are computed from the same edge derivatives:
Figure 2. The underlying mechanism: a shared graph convention, a unified data object, and a shared derivative route. (a) A structure becomes a graph: atom bonds to atom within the cutoff . (b) The unified data object: AtomsData, which describes the graph and its associated data. (c) The architecture-independent forward pass that yields forces, stress and virial.
where is the virial tensor, is the simulation cell volume, and is the stress tensor. Because the virial is constructed from the same per-edge gradients as the forces, no additional backward pass through the network is required. In molecular dynamics simulations, the kinetic contribution to the pressure is added by the integrator rather than computed by the model.
Training objective
Models are trained by minimizing a weighted combination of energy, force, virial, and stress residuals:
where the energy weight is determined automatically from the user-specified derivative weights to ensure . The energy loss term uses mean-squared error normalized per atom:
where is the batch size, and are the predicted and reference energies for structure , and is the number of atoms in structure . This per-atom normalization prevents large structures from dominating batches with heterogeneous system sizes. The force loss term uses the mean Euclidean norm of the per-atom force error:
where is the total number of atoms in the batch, and and are the predicted and reference forces on atom . This norm in force space is rotationally invariant and less sensitive to outliers than the squared () norm. Optionally, training targets are standardized using the mean and standard deviation of the per-atom training energies, and predictions are de-standardized within the model before output. This ensures that saved model checkpoints always predict energies in physical units regardless of the standardization used during training.
Related work
Several mature frameworks address different aspects of the MLIP workflow. SchNetPack[29, 30] pioneered the concept of a modular atomistic deep-learning toolbox with reusable data pipelines, training loops, and ASE integration, establishing a benchmark for usability. Its model zoo focuses on the SchNet, PaiNN, and FieldSchNet architectures. DeePMD-kit[31, 32] is widely deployed in the production environment, offering highly optimized descriptors, extensive MD engine integration, and mature HPC support. However, it is built around the Deep Potential model family rather than the equivariant graph neural networks that currently define the state-of-the-art in accuracy. GPUMD[33] achieves exceptional molecular dynamics throughput using the neuroevolution-potential (NEP) model, though it is similarly limited to a single architecture family. TorchMD-NET[34] implements equivariant transformer architectures with specialized support for biomolecular simulations. The reference implementations of NequIP [15], Allegro [16], MACE [17], and the Equiformer family [18, 19] are well-engineered within their respective scopes. However, each constitutes a separate package with its own data format, configuration schema, and deployment workflow, preventing interoperability: models cannot generally be exchanged or compared directly across these frameworks. Workflow-level tools address complementary challenges: CURATOR [35] and DP-GEN [36] automate active learning and dataset generation, while AdsorbML [37] provides an efficient screening protocol that combines pre-trained potentials with selective DFT refinement.
IANN occupies the intermediate layer between individual model implementations and high-level workflow tools. Rather than proposing novel architectures or active-learning strategies, it standardizes the software interface—encompassing data objects, training loops, model checkpoints, ASE calculators, and MD engine exports—enabling architectures with fundamentally different inductive biases to be trained, compared, and deployed through identical code paths. Three key features distinguish IANN from existing frameworks. First, architecture selection becomes a controllable experimental variable that can be systematically varied while holding all other factors constant—precisely what is required for rigorous benchmarking on domain-specific datasets. Second, deployment is fully model-agnostic: because all architectures expose a unified tensor-level interface, a single TorchScript wrapper and a single pair of LAMMPS pair styles support all models, including ensemble predictions. Third, HPC parallelism is managed by the framework rather than requiring user intervention. This design choice is practically significant because training workflows must often execute seamlessly across diverse computing environments, from local workstations to HPC clusters with varying job schedulers and MPI implementations.
Software structure
Figure 1 shows the structure of IANN, which consists of five main layers with two auxiliary ones. It starts from first layer, data layer (iann.data) as shown in the bottom in Figure 1, which serves unified data to the second layer, models (iann.models) and trainer (iann.trainer) layer. There are plenty of MLIPs architectures that can be chosen and trained on the unified trainer on a single GPU or in parallel across many. Training writes a self-describing checkpoint that the third layer consumes either as an ASE calculator via iann.calculators (with optional ensemble support) or as a TorchScript model compiled for LAMMPS via iann.plugins. Two auxiliary layers attach to these: iann.foundations supplies pre-trained potentials at three levels of DFT theory, to be reused directly or refined by the trainer, and the bundled pair styles execute the compiled model inside LAMMPS. The fourth layer is the calculations those two interfaces drive, such as surrogate DFT single points, relaxations and nudged-elastic-band searches, enhanced sampling, and molecular dynamics. The final layer (fifth layer) encompasses the application domains served by IANN: catalysis, battery materials, and drug discovery. The subsections that follow describe these architectural layers in sequence.
Figure 1. Software structure of the IANN framework: five main layers with two auxiliary layers.
Data layer
In order to deal with various structure formats, and to turn them into the graph that a model can consume, IANN provides a unified data layer (iann.data). Trajectory or database are read through ASE that can support various formats. The neighbour lists that define the graph nodes and edges are built by a C++ compiled asap3 whose cost grows linearly with the number of atoms. Both are packed into a unified data object, AtomsData, which is natively accepted by every architecture and readily compiled via TorchScript. This allows the same object to serve both training in Python and inference inside LAMMPS in C++. More detailed construction can be found in Section S2 of the Supporting Information.
Models and trainer layer
Based on the unified data object, the second layer implements several state-of-the-art MLIPs architectures alongside a template for custom models (iann.models), all managed through a unified trainer (iann.trainer). The trainer handles the training loop, the objective on energies, forces, stresses and virials, logging, checkpointing, learning-rate scheduling, early stopping, and restarts. It also detects the environment and configures distributed data-parallel training automatically from SLURM, PBS, OpenMPI, MPICH/Intel MPI, or MVAPICH2 without any change to the script. The architectures — PaiNN[14] NequIP[15] MACE[17] Allegro[16] EquiformerV2[19] EquiformerV3[20] and UMA[21] — are available by their name in a configuration dictionary. Each is reimplemented against the shared AtomsData interface, so that one data object, one derivative route, and one exporter serve them all. The accuracies reported here are therefore those of the IANN implementations rather than of the original releases. The same trainer then supplies the objective and runs on a single GPU or in parallel across many[38] without a change to the script. The trainer configurations and the corresponding implementation details are described in full as Section S2 and § 5.10.
Calculators and plugins layer
After training a model, a unified and user-friendly interface is needed to load the trained checkpoint for doing calculations, which is exactly what the third layer provides. The third layer provides unified calculators (iann.calculators and plugins iann.plugins), making the full ASE ecosystem directly accessible without requiring additional code. In addition, EnsembleCalculator can utilise ensemble checkpoints to do prediction with variance of total energy, forces, and atomic properties (like atomic energy) directly as an acquisition signal for active learning.[39, 40] The LAMMPS plugin can use the compiled TorchScript single model or ensemble model to do inference in serial or in parallel, which does not depend on the specific architectures.
Calculations layer and applications layer
Building directly on the third layer, the calculations layer invokes these calculators and plugins to drive various atomistic simulations: single-point evaluation, geometry relaxation, and nudged-elastic-band searches through ASE as surrogates for the corresponding DFT calculations, molecular dynamics through either ASE or LAMMPS, and free-energy methods such as metadynamics through ASE-PLUMED calculator. These calculations serve the application domains at the top of Figure 1, which include catalysis, battery materials, and drug discovery.
Foundation models
To accelerate project workflows and avoid training models from scratch, IANN distributes pretrained foundation potentials (iann.foundations). The foundation models are released,[27] trained on 41.9 million curated DFT structures and grouped by exchange-correlation functional. Each model can serve directly as a zero-shot calculator or as an initialization checkpoint for fine-tuning on targeted in-house data to boost predictive accuracy (see § 1.6.4).
Deployment to LAMMPS
To bypass the size and timescale bottlenecks of Python-driven simulations, IANN deploys compiled models directly inside LAMMPS (pair_style iann). Built on the LibTorch C++ API, the pair styles run in serial or multi-GPU parallel configurations. Furthermore, the plugin natively supports ensemble predictions: loading an ensemble checkpoint automatically instantiates a companion compute that streams energy and force variances alongside standard thermodynamic variables, enabling real-time detection of out-of-distribution drift.
Agent interface
Beyond the core framework, an agent interface exposes these underlying operations programmatically, enabling fully autonomous model training, inspection, and deployment without human intervention. Instead of introducing a separate layer into Figure 1, the agent interface serves as a parallel entry point to the core stack through three complementary mechanisms: structured CLI output, an MCP server, and task-specific agent skills. Detailed descriptions of each interface and the constraints governing autonomous execution are provided in § 5.9 of the Supporting Information.
Underlying mechanism
The core architectural mechanism enabling the uniformity across Figure 1 is illustrated in Figure 2. It comprises three key components: a shared graph convention, a unified data object consumed and produced by every model, and a single analytic derivative pathway. The details of each component are described below.
Graph convention
Before processing by any architecture, an atomic structure is converted into a graph representation. This graph is materialized as node and edge tensors according to Eq. (2). The nodes are represented by a single integer array of atomic numbers, and the edges by integer indices array and edge vectors . The graph is directed, so each edge appears twice: once from to and once from to . For periodic boundary conditions, the lattice shift vector is incorporated during graph construction. Crucially, the edge vectors are flagged to track gradients, enabling the unified, single-step differentiation detailed below.
Unified data object
The graph is packaged into a unified data structure (AtomsData) that every architecture consumes and returns, making the trainer and calculators architecture-agnostic. This data object also carries training labels, batching indices, optional intermediate representations, predictive variances, and ensemble metadata. The data object is also compatible with TorchScript, which allows the same model object to be compiled for LAMMPS without an architecture-specific adapter.
Derivative route
The architecture-independent forward pass in Figure 2c closes the loop. Every architecture implements an identical forward signature—mapping AtomsData to AtomsData—and extracts atomic forces through a single differentiation with respect to edge vectors (Eq. (6)). A subsequent contraction of these same per-edge gradients against the edge vectors yields the virial and Cauchy stress (Eq. (7)), allowing all three derived physical quantities to be obtained in a single backward pass. The loss functions, trainer, calculators, and TorchScript exporter are implemented against that signature alone and contain no architecture-specific logic. This design offers two key advantages. First, selecting a network architecture is reduced to a simple configuration parameter, allowing different models to be trained and evaluated using a single unified script. Second, a universal wrapper exports any supported architecture to LAMMPS, ensuring that adding a new model leaves the downstream deployment pipeline untouched.
A complete workflow
A primary design objective of IANN is usability, enabling practitioners to train and deploy models with minimal code and without low-level framework knowledge. As shown below, Listing 1 demonstrates how to train a model directly from an ASE trajectory. Switching between supported architectures—including nequip, mace, allegro, equiformerV2, equiformerV3, and UMA—requires only modifying the model name and corresponding hyperparameters in the config dictionary. Furthermore, custom architectures can be integrated into the framework with minimal boilerplate, as illustrated below.
Listing 1: Training a model with a registered architecture.
from iann.trainer import Trainer
trainer = Trainer(
model="painn",
config={"num_channels": 128,
"num_layers": 3,
"cutoff": 5.5,
"batch_size": 16,
"learning_rate": 1e-4,
"forces_weight": 0.9,
"val_ratio": 0.1,
"device": "cuda",
"output_dir": "output"},
distributed=True,
)
trainer.train("dataset.traj")
The resulting checkpoint is loaded into an ASE calculator in Listing 2 to drive downstream calculations. Because each checkpoint encapsulates its network architecture and hyperparameters, the calculator automatically reconstructs the underlying model without manual specification.
Uncertainty quantification is equally seamless: swapping MLCalculator for EnsembleCalculator with a list of checkpoints yields both mean predictions and calibrated variances. Finally, deployment to LAMMPS requires only a single export step to generate a TorchScript model compatible with pair_style iann.
Listing 2: Running inference with a model checkpoint with its own architecture and parameters.
from ase.io import read
from ase.optimize import BFGS
from iann.calculators import MLCalculator
atoms = read("start.traj")
atoms.calc = MLCalculator("output/model.pt", device="cuda")
BFGS(atoms, trajectory="relax.traj").run(fmax=0.03)
Results and discussion
Curated DFT databases
Training a robust foundation potential requires DFT data generated at a consistent level of theory. However, existing public DFT repositories use a range of exchange-correlation functionals and vary in structural quality. To address this, we systematically screened the source databases for conspicuous energy and force outliers and removed them prior to training. After filtering, we categorized the databases by exchange-correlation functionals and converted them into a standardized ASE trajectory format (Table 1), which the framework ingests directly without requiring auxiliary preprocessing or database conversion. The PBE[50] database includes MPtrj,[41, 42] sAlex (subsample of Alexandria),[43, 44] OMat24,[44] MatPES,[45] and OC22, which cover 89 elements for bulk and surface chemistry;[46] the RPBE[51] database includes OC20[47] and OC25,[48] which together cover the catalysis-relevant surface and solid–liquid-interface chemistry with 73 elements; and the rSCAN[52] database includes the meta-GGA subsets of the Materials Project[49] and MatPES, which cover 89 elements.[45] The detailed system information, total structure counts, atom counts (in millions), and element coverages for each database are provided in Table 1. It can be noted that the PBE database is the largest by structure count, with 31.9 million structures, followed by the RPBE database with 9.37 million, and the rSCAN database with 0.63 million. When measured by atom count, the order of the first two is inverted: the RPBE dataset comprises 1,210.8 million atoms compared to 972.0 million for PBE and 8.1 million for rSCAN. This inversion arises because the surface and interface supercells in the RPBE sources are substantially larger than the bulk unit cells that dominate the PBE collection.
| Functional | Source dataset | System type | Structures | Atoms (M) | Elem. | Ref. |
| PBE | MPtrj | Bulk, relaxations | 1,579,091 | 49.2 | 89 | [41, 42] |
| PBE | sAlex | Bulk, relaxations | 10,423,284 | 107.5 | 89 | [43, 44] |
| PBE | OMat24 | Bulk, off-equilibrium | 11,274,650 | 157.1 | 89 | [44] |
| PBE | MatPES | Bulk, MD snapshots | 434,092 | 3.9 | 89 | [45] |
| PBE | OC22 | Surfaces, oxides | 8,199,197 | 654.3 | 57 | [46] |
| PBE | PBE total | 31,910,314 | 972.0 | 89 | ||
| RPBE | OC20 (2M) | Surfaces, relaxations | 1,999,572 | 146.5 | 56 | [47] |
| RPBE | OC25 | Solid–liquid interf. | 7,370,461 | 1064.3 | 73 | [48] |
| RPBE | RPBE total | 9,370,033 | 1210.8 | 73 | ||
| MP | Bulk, relaxations | 238,241 | 5.0 | 88 | [49] | |
| MatPES | Bulk, MD snapshots | 387,306 | 3.0 | 89 | [45] | |
| total | 625,547 | 8.1 | 89 |
Table 1. Curated DFT databases grouped by exchange-correlation functional.
These three DFT levels databases also differ markedly in chemical diversity and dataset scale as shown in Figure 3. Each periodic table tile indicates the element count and is shaded on an independent logarithmic scale according to its functional-specific colormap: blue for PBE, orange for RPBE, and green for rSCAN. Darker tones correspond to higher counts, while dashed gray cells designate elements absent from that dataset. The PBE and rSCAN databases span nearly the entire periodic table—including the lanthanides and actinides up to plutonium (Pu)—yet differ in depth by more than an order of magnitude. Conversely, the RPBE database exhibits a narrower elemental breadth, containing no actinides and only five lanthanides, but compensates with massive statistical depth: it encompasses 9.0 million structures containing hydrogen and 8.6 million containing oxygen, directly reflecting its provenance in surface science and solid–liquid interface catalysis. In addition, complete per-element, per-atom, and structure counts for each database are mapped onto periodic tables in Section S16 in the Supporting Information. Altogether, the curated collection contains 41.9 million labeled configurations, accessible through Hugging Face Datasets.[26]
Figure 3. Elemental composition of three levels of curated DFT databases: number of structures containing each element on a logarithmic colour scale. Each element tile is divided into three stepped sub-cells from top left to bottom right, corresponding to PBE, RPBE, and rSCAN.
Foundation models across architectures
Seamless cross-architecture training is a cornerstone of IANN, enabling users to train diverse model architectures on an identical dataset with minimal modifications to the configuration script. Here, we present a systematic benchmark comparing the energy and force prediction accuracy across multiple architectures trained on the same database. While this benchmark is not designed as a controlled ablation study, it provides a realistic assessment of empirical performance in practical deployments. Model parameter count serves as the common metric of comparison. Consequently, aside from the distinct network architectures and their parameterizations, all models share identical training splits, graph conventions, loss formulations, and evaluation routines. We trained seven architectures on the curated MPtrj database (1,579,091 PBE structures) under uniform training settings: a 5.5 Å interaction cutoff, the Adam optimizer, identical gradient clipping, and standardized early-stopping patience. For the loss function in Eq. (9), we adopted a staged weighting scheme, transitioning from to emphasize force learning early on to to optimize asymptotic energy accuracy. For each architecture, channel widths, layer depths, and angular resolutions (, ) were selected to standardize model capacity around 1 million parameters (spanning 0.57 to 1.43 M). Learning rates were tuned independently for each network to match its characteristic optimization dynamics.
Table 2: Validation accuracy and parameter counts for seven representative architectures trained via IANN on the curated MPtrj dataset. [27] Parameter count serves as the common metric of model capacity across disparate architectures; network depth, channel dimensions, and angular resolutions for each model are detailed in Table S2.
The energy and forces accuracies of the seven architectures are summarized in Table 2. Validation errors are evaluated on a held-out 5% split of the curated MPtrj dataset using the mean absolute error (MAE). Here, models are deliberately constrained to approximately 1 million parameters to ensure rapid inference and facilitate lightweight fine-tuning. Two key trends emerge from these results. First, when evaluated on the same benchmark at comparable model capacities, energy errors vary relatively little across architectures, from 0.029 to 0.054 eV/atom, whereas force errors show a wider spread, from 0.040 to 0.069 eV/. Second, attention-based architectures achieve the strongest overall accuracy on this dataset: EquiformerV3 delivers competitive energy and force errors of 0.040 eV/atom and 0.046 eV/ with 0.94 M parameters, while UMA achieves the lowest errors overall, recording an energy error of 0.029 eV/atom and a force error of 0.040 eV/ but uses more parameters, at 1.17 M. PaiNN is also highly competitive: with just 0.60 M parameters, it achieves errors of 0.041 eV/atom for energy and 0.050 eV/ for forces, while delivering the fastest inference throughput (Table S6). This balance of accuracy, efficiency, and speed motivates our choice of PaiNN as the core architecture for the foundation potentials at all three DFT levels.
| Model | Parameters | (eV/atom) | (eV/Å) |
| PaiNN | 600,577 | 0.041 | 0.050 |
| NequIP | 1,379,513 | 0.050 | 0.069 |
| Allegro | 567,624 | 0.040 | 0.066 |
| MACE | 1,429,376 | 0.054 | 0.069 |
| EquiformerV2 | 773,089 | 0.040 | 0.059 |
| EquiformerV3 | 943,249 | 0.040 | 0.046 |
| UMA | 1,173,698 | 0.029 | 0.040 |
Table 2.
| Architecture | Params | Floor (ms) | Crossover (µs/atom) | Max | Mem @ (GiB) | MD (ns/day) | (meV/at.) | (meV/Å) | |
| PaiNN | 600,581 | 9.0 | 15.9 | 564 | 10,976 | 1.36 | 3.00 | 41 | 50 |
| NequIP | 1,383,079 | 24.3 | 18.5 | 1,316 | 10,976 | 0.92 | 2.03 | 50 | 69 |
| Allegro | 570,062 | 19.1 | 180.7 | 106 | 4,000 | 5.72 | 0.76 | 40 | 66 |
| MACE | 1,435,686 | 20.8 | 15.0 | 1,391 | 10,976 | 0.76 | 2.23 | 54 | 69 |
| EquiformerV2 | 773,093 | 114.6 | 306.7 | 374 | 864 | 19.77 | 0.36 | 40 | 59 |
| EquiformerV3 | 966,081 | 53.6 | 171.6 | 312 | 2,048 | 13.28 | 0.66 | 40 | 46 |
| UMA | 1,174,121 | 28.4 | 91.4 | 311 | 6,912 | 4.32 | 1.19 | 29 | 40 |
Table S6. Table S6: Inference cost and accuracy of different architectures on one Tesla V100-PCIE-32GB, float32, 5.5 Å cutoff for energy+forces on bulk fcc Pt supercells.
Foundation models at three DFT levels
Table 3: PaiNN foundation models within IANN grouped by three levels of DFT exchange-correlation functional.[27] Each model is trained on a single source database. Errors here are evaluated across entire source databases rather than on validation sets.
Leveraging the curated datasets in Table 1, we trained foundation potentials across all three DFT levels, using PaiNN as the underlying architecture. Training was conducted under identical architectural hyperparameters—128 channels, 3 interaction layers, a 5.5 cutoff, and 600,577 total parameters—ensuring that performance variations across rows reflect dataset composition rather than model capacity. Each model was optimized using the per-atom energy loss, a batch size of 16, and an initial learning rate of . In the final training phase, each run was restarted at a reduced learning rate directly through the trainer, facilitating asymptotic convergence without resetting the optimizer state from scratch. As summarized in Table 3, we provide five foundation potentials at the PBE level, two at the RPBE level, and two at the SCAN level, each trained on an individual database. We deliberately avoid merging datasets within a given functional because underlying DFT parameters, such as Hubbard corrections and D3 dispersion schemes, differ across source repositories. Distributing separate models per source preserves internal thermodynamic consistency
| Functional | Model Name | Database | Structure Count | (eV/atom) | (eV/) |
| PBE | PBE-MPtrj | MPtrj | 1,579,058 | 0.0517 | 0.0498 |
| PBE-sAlex | sAlex | 10,422,893 | 0.0408 | 0.0513 | |
| PBE-OMat24 | OMat24 | 11,261,400 | 0.0261 | 0.1382 | |
| PBE-MatPES | MatPES | 434,083 | 0.0463 | 0.0930 | |
| PBE-OC22 | OC22 | 8,198,695 | 0.0381 | 0.0528 | |
| RPBE | RPBE-OC20 | OC20 | 1,999,216 | 0.0263 | 0.0630 |
| RPBE-OC25 | OC25 | 7,369,601 | 0.0116 | 0.0753 | |
| r²SCAN | r²SCAN-MPtrj | MPtrj | 238,241 | 0.0206 | 0.0117 |
| r²SCAN-MatPES | MatPES | 387,285 | 0.0446 | 0.1127 |
Table 3. PaiNN foundation models within IANN grouped by three levels of DFT exchange-correlation functional. Each model is trained on a single source database. Errors here are evaluated across entire source databases rather than on validation sets.
and allows practitioners to select the checkpoint whose reference settings most closely match their target application. Across all models, training dataset size does not strictly correlate with final validation error. For PBE, per-database energy MAEs range from 0.0261 to 0.0517 eV/atom, higher than those for RPBE (0.0116 to 0.0263 eV/atom) and comparable to SCAN (0.0206 to 0.0446 eV/atom). Force MAEs for PBE span 0.0498 to 0.1382 eV/, exhibiting wider variance than RPBE (0.0630 to 0.0753 eV/) and SCAN (0.0117 to 0.1127 eV/). The elevated force errors observed for PBE-OMat24 and SCAN-MatPES reflect their strong off-equilibrium sampling, which includes heavily rattled geometries in OMat24 and high-temperature dynamic configurations in MatPES.
To enable direct comparison, the validation energy and force MAEs from Table 3 are plotted against one another in Figure 4a, with the corresponding training dataset sizes shown in Figure 4b. We can note that SCAN-MPtrj achieves the lowest force MAE (0.0117 eV/), while RPBE-OC25 attains the lowest energy MAE (0.0116 eV/atom). Notably, predictive accuracy does not correlate monotonically with dataset scale: RPBE-OC25 is trained on 7.4 million configurations yet records the lowest energy error, whereas SCAN-MatPES is trained on 387,285 structures but yields an elevated force MAE of 0.1127 eV/. This demonstrates that foundation model fidelity is governed not merely by dataset volume, but critically by structural diversity and configuration space sampling. While Figure 4a summarizes global accuracies, elemental transferability is often more decisive in practice. To this end, Figure 4c–Figure 4h resolve energy and force errors as a function of atomic number across all PBE, RPBE, and SCAN functionals. Although per-element accuracy varies markedly across the periodic table, the elemental profiles within a single functional remain strikingly congruent across different source databases. This consistency demonstrates that elemental error trends are primarily dictated by the underlying level of theory rather than dataset provenance. Detailed per-element MAE values for each model are summarized in § 5.23 in the Supporting Information.
Figure 4. The PaiNN foundation models trained on each DFT database. (a) Energy MAE against force MAE. (b) Number of structures that each was trained on. (c, e, g) Per-element energy MAE against atomic number. (d, f, h) Per-element force MAE against atomic number for the PBE, RPBE and SCAN functionals, respectively.
Fine-tuning foundation models
The foundation models provide the intended starting baselines for downstream fine-tuning where high task-specific precision is required. In typical computational catalysis workflows, the DFT calculations for a specific reaction coordinate are limited to a few hundred configurations, well below the sample volume required for training from scratch. Fine-tuning a pre-trained foundation model on this sparse dataset readily adapts the potential to the target chemistry. Within IANN, fine-tuning is executed simply by loading the pre-trained checkpoint and resuming optimization on the specialized in-house dataset. The training routine remains identical to Listing 1, requiring only that the model arguments point to the desired foundation checkpoint. To evaluate the fine-tuning performance, we validated the model on AdsTraj, an independent RPBE dataset comprising 33,920 configurations across 26 transition metals, six representative adsorbates (H*, C*, O*, CO*, OH*, and HOCO*), and diverse adsorption sites. [53] The dataset was split into 90% training and 10% test partitions. As shown in Figure 5a, the zero-shot energy MAE of the RPBE-OC20 PaiNN foundation model fluctuates across metals and adsorbates, highlighting the inherent non-uniformity of generalized priors across chemical space. The aligned column bars in Figure 5b compute the ensemble MAE per element across all sampled frames, showing an overall baseline error of 0.024 eV/atom with particularly high fidelity on metals including V, Co, Ni, Cu, Y, Zr, Pd, Ag, Hf, Ta, W, and Au. Parity plots comparing adsorption energies under zero-shot, trained from scratch, and fine-tuned are illustrated in Figure 5c–Figure 5e, with quantitative benchmarks summarized in Table 4. It can be observed that zero-shot evaluation shows an MAE of 0.715 eV with an of 0.846, which has lower accuracy than the model trained from scratch on AdsTraj alone (0.483 eV MAE, ). Notably, the fine-tuned RPBE-OC20 checkpoint dramatically outperforms both baselines, reducing the MAE to 0.217 eV and achieving an of 0.986. These findings
Figure 5. Benchmark performance of the RPBE-OC20 PaiNN foundation model on the AdsTraj. (a) Heatmap of energy MAE across transition metal surfaces (Sc to Au) and key catalytic adsorbates (C*, H*, O*, CO*, OH*, and HOCO*). (b) Energy MAE resolved across metals. Parity plots of adsorption energy under (c) zero-shot, (d) from scratch, and (e) fine-tuning.
| Strategy | Training structures | MAE (eV) | |
| Zero-shot (foundation model) | 0 | 0.715 | 0.846 |
| From scratch (train from scratch) | 24,154 | 0.483 | 0.926 |
| Fine-tuned (train on foundation model) | 24,154 | 0.217 | 0.986 |
Table 4. Performance comparison across zero-shot, training from scratch, and fine-tuning.
demonstrate that pre-trained foundation models provide superior inductive priors, enabling fine-tuned potentials to decisively surpass models trained from scratch within identical, data-scarce regimes.
Per-atom energy and force errors across varying training-set sizes are summarized in Table S4 in the Supporting Information. Notably, when trained on the full dataset, the fine-tuned model attains the lowest per-atom energy error (7.1 meV/atom) and force error (36.7 meV/), substantially outperforming both the zero-shot foundation model (24.0 meV/atom and 67.2 meV/) and the model trained from scratch (14.1 meV/atom and 45.4 meV/). Throughout the data-scaling series, the fine-tuned model consistently surpasses the model trained from scratch at every training-set size. This demonstrates that pre-trained representations accelerate convergence and enhance predictive accuracy in data-limited regimes, confirming that the pre-trained weights supply superior inductive priors relative to random initialization across all stages of fine-tuning.
| Strategy | Structures | (meV atom) | (meV Å) | (eV) |
| Zero-shot | 0 | 25.0 | 67.2 | 0.715 |
| From scratch | 86 | 2283.6 | 565.7 | 71.1 |
| From scratch | 1,023 | 794.0 | 181.4 | 28.2 |
| From scratch | 2,119 | 524.6 | 223.7 | 18.1 |
| From scratch | 5,424 | 32.2 | 91.5 | 1.033 |
| From scratch | 11,991 | 19.7 | 65.5 | 0.689 |
| From scratch | 24,154 | 14.1 | 45.4 | 0.483 |
| Fine-tuned | 86 | 89.6 | 79.2 | 3.058 |
| Fine-tuned | 1,023 | 42.9 | 77.7 | 1.669 |
| Fine-tuned | 2,119 | 26.0 | 64.0 | 0.969 |
| Fine-tuned | 5,424 | 16.6 | 53.6 | 0.513 |
| Fine-tuned | 11,991 | 9.1 | 49.4 | 0.324 |
| Fine-tuned | 24,154 | 7.1 | 36.7 | 0.217 |
Table S4. Data efficiency of fine-tuning on the AdsTraj dataset.
Inference cost across architectures
While model accuracy is a primary criterion of merit, computational efficiency is an equally vital consideration, especially for long-timescale and large-scale applications such as molecular dynamics and high-throughput screening.[54] To provide a comprehensive assessment beyond static error metrics, we benchmark the inference cost across all seven architectures trained on the MPtrj database. The wall-clock time per evaluation against the number of atoms, peak GPU memory versus the number of atoms, force MAE versus sustained throughput, and NNP speedup over DFT (VASP, RPBE functional) are considered to evaluate the cost for each model (Figure 6). All benchmarks were conducted in single precision (float32) on a single NVIDIA Tesla V100 GPU (32 GB), evaluating bulk supercells ranging from 32 to 10,976 atoms under the standardized 5.5 cutoff.
Figure 6. Inference cost of the architectures via IANN. (a) Wall time per energy-and-force call against system size. (b) Peak GPU memory versus the number of atoms. (c) Force MAE against sustained throughput for each model. (d) NNP Speedups over DFT (VASP, RPBE). The shaded region is where the DFT reference is extrapolated.
Figure 6a plots the wall-clock execution time per energy-and-force evaluation as a function of system size across all architectures. Open circles identify the transition threshold , marking the crossover from the latency-bound regime to the throughput-bound scaling regime, while crosses denote the maximum system size reached before encountering out-of-memory (OOM). We can see that each architecture exhibits a distinct latency floor below which evaluation time is invariant to system size, reflecting a regime where kernel launch overhead dominates and GPU compute capacity remains underutilized. These latency floors range from 9.0 ms for PaiNN, to 19–28 ms for NequIP, MACE, Allegro and UMA, reaching 54 ms for EquiformerV3 and 115 ms for EquiformerV2. This indicates that PaiNN requires the shortest time for GPU kernel launches and data transfers, whereas EquiformerV2 takes the longest. Meanwhile, NequIP, MACE, Allegro, and UMA exhibit similar latency floor times, and EquiformerV3 lies intermediate between this group and EquiformerV2. The crossover at which the per-atom cost begins to dominate ranges from about 100 atoms for Allegro to roughly 1400 for MACE and NequIP. Above the cost is linear in as the locality of Eq. (1) requires. For the few-hundred-atom slabs typical of surface catalysis, architectural selection is effectively governed by the baseline latency floor rather than marginal scaling, as per-atom overhead remains negligible until systems reach significantly larger scales. In this regime, MACE, PaiNN, and NequIP demonstrate the lowest marginal per-atom cost, while
UMA, EquiformerV3, Allegro, and EquiformerV2 exhibit steeper scaling slopes. Figure 6b displays peak GPU memory allocation versus system size, revealing strict linear scaling with atom count across all models. Consistent with the computational latency trends in Figure 6a, PaiNN, NequIP, and MACE maintain the lowest memory footprints, allowing them to simulate substantially larger systems before encountering GPU memory ceilings compared to the heavier architectures.
Force MAE against sustained throughput for each model is shown in Figure 6c. Sustained throughput is defined as the number of atoms normalized by wall-clock time per energy-and-force call. In this metric, PaiNN, NequIP, and MACE exhibit higher throughput than UMA, EquiformerV3, Allegro, and EquiformerV2, reflecting their lower per-call computational cost. However, UMA, EquiformerV3, and PaiNN attain the lower force MAEs than NequIP, MACE, Allegro, and EquiformerV2, which indicates that they are more accurate in terms of force prediction in current configurations. Balancing this trade-off between predictive error and inference latency is essential when tailoring architecture selection to target application scales.
Figure 6d compares the computational speedups of different models relative to plane-wave DFT (VASP, RPBE). Across all architectures, the neural network potentials achieve speedups ranging from three to six orders of magnitude over DFT. In the extrapolated DFT regime (shaded region in Figure 6d), this computational advantage widens progressively with system size, underscoring the benefit of neural network potentials for large-scale simulations. Furthermore, inter-model performance varies by up to between the fastest and slowest architectures—a performance gap that translates into substantial wall-clock savings during high-throughput screening or long-timescale molecular dynamics runs.
Parallel performance
Parallel performance divides into two parts: training parallelism and inference parallelism. Scalable multi-GPU training is essential for pre-training large models on massive structural datasets. To evaluate multi-GPU scaling efficiency and sustained throughput across architectures, we benchmarked training on the curated MPtrj dataset across 1 to 16 NVIDIA A100 GPUs (configured with one MPI rank per GPU) under a fixed per-device batch size, as shown in Figure S13. It can be seen that training acceleration scales near-linearly as GPU counts increase, with individual architectures achieving speedups between and across 16 GPUs. Consequently, parallel training efficiency gradually attenuates with scale, spanning from 65.7% to 86.0% at 16 GPUs. Aggregate training throughput scales concurrently with GPU allocation, though absolute performance diverges markedly across architectures, ranging from 323 to 3,892 structures per second on 16 GPUs. Overall, while parallel scaling efficiency gradually declines with increasing GPU counts across all models, MACE, NequIP, and PaiNN sustain the highest multi-GPU training throughput, in close alignment with their favorable memory and latency profiles in Figure 6b. In addition, we profiled the computational budget of an individual training iteration across five key components: data loading with neighbor-list construction, host-to-device transfer, forward and backward passes, the gradient all-reduce, and the optimizer update with gradient clipping. It can be seen that graph evaluation, neighbor-list building, and gradient synchronization clearly dominate the training overhead. Complete scaling measurements and timing distributions are detailed in Figure S13 and Tables S9 and S10 in the Supporting Information.

Figure S13. Parallel training on 1–16 A100 GPUs, batch 16 structures per rank, on the cleaned MPtrj database. (a) Speedup against rank count, with the ideal line. (b) Parallel efficiency. (c) Global throughput in structures per second. (d) Where one training step goes at : data loading and neighbour-list construction, host-to-device transfer, forward and backward, the gradient all-reduce, and gradient clipping plus the optimizer update. The all-reduce share is what separates the curves in (b).
Inference parallelism denotes distributing model evaluation across multiple GPUs, which is essential for large-scale simulations. We evaluated the parallel inference scalability of IANN using the PaiNN foundation potential deployed through our native LAMMPS interface (pair_style iann/multi_gpu). Benchmarks were conducted on thermally rattled FCC Cu supercells across 1 to 8 NVIDIA A100 GPUs (80 GB), assigning one MPI rank per GPU. Figure 7a presents the wall-clock time per MD step across system sizes and GPU allocations. It can be seen that the per-step wall-clock latency decreases systematically as additional GPUs are allocated, with multi-GPU acceleration becoming particularly pronounced for larger systems. Conversely, for smaller systems below approximately 5000 atoms, scaling up to 8 GPUs yields no performance gain due to device underutilization and communication bottlenecks. When compared against the serial baseline, execution on 1 or 2 GPUs using the parallel implementation incurs higher latency across all system sizes. This runtime penalty occurs because spatial domain decomposition in pair_style iann/multi_gpu requires each MPI rank to evaluate extended ghost-atom buffers across subdomain boundaries. Consequently, the aggregate atom count evaluated across ranks exceeds that of serial execution, increasing per-step computation. Additionally, inter-GPU and cross-node communication overhead adds to the total wall-clock time per MD step. Beyond two GPUs, however, per-step wall-clock latency drops below the serial baseline for sufficiently large systems, confirming that distributed compute gains outpace communication overhead as system scale expands. Parallel inference efficiency is illustrated in Figure 7b: parallel efficiency diminishes with higher GPU counts, with smaller systems suffering greater efficiency losses. For instance, in an 864-atom supercell, 8-GPU efficiency drops below 20%. However, when the number of atoms is larger than 23k, the parallel efficiency is about 50%, which is fully consistent with Figure 7a.
Figure 7. Performance of the IANN LAMMPS interface on A100-80GB GPUs. (a) Time per MD step against the number of atoms for 1–8 GPUs. (b) Parallel efficiency against GPU count. (c) Throughput against the number of atoms. (d) Maximum number of atoms versus GPU count.
Sustained throughput, defined as atom count normalized by wall-clock time per MD step, is illustrated in Figure 7c. Computational throughput increases steadily with GPU allocation across all scales, except for the 8-GPU configuration on small systems. In large-scale regimes (around 30k atoms), the 8-GPU throughput reaches approximately that of single-GPU parallel execution (iann/multi_gpu) and that of the serial baseline. The maximum number of atoms that can be handled is also evaluated, and shown in Figure 7d. Cross markers indicate configurations that encountered out-of-memory errors. It can be seen that the maximum atom capacity scales linearly with GPU count: only 25,000 atoms can be handled on 1 GPU, while 200,000 atoms can be handled on 8 GPUs, which is an exact eightfold increase. This indicates that the maximum number of atoms is limited by the available GPU memory. Furthermore, the serial implementation handles roughly twice the capacity of the single-GPU parallel configuration, as serial execution bypasses ghost-atom buffer allocation across subdomain boundaries. Overall, parallel inference achieves high scalability in the large-system regime, while total atom capacity remains strictly memory-bound. Comprehensive numerical records, including per-step execution times, parallel efficiencies, and memory thresholds across all configurations, are detailed in Table S11 in the Supporting Information.
| Time per step (s) | Parallel efficiency (%) | ||||||||
| 1 GPU | 2 GPUs | 4 GPUs | 8 GPUs | (atom step s) | serial (s) | ||||
| 864 | 0.0896 | 0.0732 | 0.0629 | 0.0854 | 61 | 36 | 13 | 10,115 | 0.0151 |
| 2,048 | 0.0990 | 0.0690 | 0.0471 | 0.1240 | 72 | 53 | 10 | 16,513 | 0.0330 |
| 5,324 | 0.1905 | 0.1506 | 0.1085 | 0.1236 | 63 | 44 | 19 | 43,074 | 0.0789 |
| 6,912 | 0.2286 | 0.1824 | 0.1480 | 0.1327 | 63 | 39 | 22 | 52,099 | 0.0994 |
| 10,976 | 0.3307 | 0.2022 | 0.1633 | 0.1488 | 82 | 51 | 28 | 73,763 | 0.1587 |
| 13,500 | 0.3876 | 0.2322 | 0.2073 | 0.1285 | 83 | 47 | 38 | 105,058 | 0.1930 |
| 16,384 | 0.4501 | 0.2724 | 0.1982 | 0.1272 | 83 | 57 | 44 | 128,825 | 0.2300 |
| 19,652 | 0.5186 | 0.3349 | 0.1866 | 0.1509 | 77 | 69 | 43 | 130,275 | 0.2849 |
| 23,328 | 0.6017 | 0.3579 | 0.2099 | 0.1636 | 84 | 72 | 46 | 142,592 | 0.3337 |
| 27,436‡P | oom | 0.4049 | 0.2347 | 0.1447 | ref | 86 | 70 | 189,567 | 0.3904 |
| 32,000‡P | oom | 0.4563 | 0.2863 | 0.1585 | ref | 80 | 72 | 201,829 | 0.4523 |
| 42,592‡P | oom | 0.5788 | 0.3357 | 0.2185 | ref | 86 | 66 | 194,884 | 0.6036 |
| 48,668‡P | oom | 0.6408 | 0.3675 | 0.2343 | ref | 87 | 68 | 207,690 | oom |
| 55,296‡P | oom | oom | 0.4170 | 0.2775 | n/a | ref | 75 | 199,243 | oom |
| 70,304‡P | oom | oom | 0.5033 | 0.3118 | n/a | ref | 81 | 225,463 | oom |
| 87,808‡P | oom | oom | 0.5955 | 0.3549 | n/a | ref | 84 | 247,402 | oom |
| 108,000‡P | oom | oom | oom | 0.4060 | n/a | n/a | ref | 266,003 | oom |
| 131,072‡P | oom | oom | oom | 0.4550 | n/a | n/a | ref | 288,102 | oom |
| 157,216‡P | oom | oom | oom | 0.5152 | n/a | n/a | ref | 305,149 | oom |
| 186,624‡P | oom | oom | oom | 0.6181 | n/a | n/a | ref | 301,917 | oom |
Table S11. The performance of the IANN LAMMPS interface of pair_style iann/multi_gpu on NVIDIA A100-80GB GPUs in Figure 7 in the manuscript is tabulated here.
Limitations
Long-range electrostatics, charge transfer, and magnetic degrees of freedom are not captured by the strictly local decomposition of Eq. (1) and remain currently unsupported.[54] Furthermore, because the released foundation models inherit the DFT parameters of their underlying training datasets, absolute energies are not transferable across different exchange-correlation functionals—the primary motivation for organizing them by functional rather than pooling them into a single model. Regarding the curated databases in Table 1, outlier filtering enhances training stability but renders them unsuitable for direct benchmarking against published literature, as the excluded structures often constitute the most physically challenging configurations; the uncurated source datasets should be used for such benchmarks. Finally, because architectures are natively reimplemented within our unified interface rather than wrapped as upstream external dependencies, checkpoint binaries from original third-party implementations cannot be loaded directly into IANN. Consequently, models within this framework must either be trained from scratch or fine-tuned from an existing IANN foundation checkpoint.
Conclusions
In this work, we presented IANN, an open-source framework for interatomic neural networks designed to bridge architectural development and production molecular modeling. By integrating diverse equivariant graph neural networks within a unified data structure, trainer, and deployment interface, IANN enables seamless architectural transitions via a single-word modification in the configuration dictionary. Across all supported architectures, atomic forces, virials, and stresses are derived through unified analytic differentiation with respect to graph edge vectors, ensuring exact evaluations under periodic boundary conditions. Furthermore, distributed data-parallel training automatically adapts to SLURM, PBS, or standard MPI schedulers, allowing a single execution script to scale without modification from multi-GPU workstations to multi-node supercomputers. Trained, self-describing checkpoints can be deployed directly as ASE calculators with optional uncertainty estimation, compiled to TorchScript predictors supporting on-the-fly variance evaluation during single- or multi-GPU LAMMPS simulations, or queried via an agent interface. This architectural uniformity facilitates rigorous, controlled benchmarking: across 1.6 million PBE-level structures, energy and force errors vary only modestly among architectures—spanning 0.029 to 0.054 eV/atom and 0.040 to 0.069 eV/, respectively. In contrast, computational latency and memory footprints diverge substantially, demonstrating that architecture selection for production simulations must be governed by accuracy–efficiency trade-offs rather than error metrics alone. Finally, our released foundation models—systematically organized by exchange-correlation functional—provide reusable inductive priors that close the loop on active-learning workflows natively backed by uncertainty quantification.
Code availability
IANN is released under the MIT license and is available at https://github.com/changzhiai/IANN, with documentation at https://iann.readthedocs.io. The version described in this paper is archived at https://doi.org/10.5281/zenodo.17809948.
Data availability
The curated reference databases of Table 1 are available at https://huggingface.co/datasets/changzhiai/dft-databases. The foundation models of Table 3 and the architecture comparison of Table 2, together with the training script, are available at https://huggingface.co/changzhiai/iann-foundation-models. The underlying published datasets are cited in Table 1 and remain the appropriate reference for benchmarking.
Acknowledgments
This research was supported by the U.S. Department of Energy, Office of Science, Office of Basic Energy Sciences, Chemical Sciences, Geosciences, and Biosciences Division, Catalysis Science Program to the SUNCAT Center for Interface Science and Catalysis. This research used high-performance computing (HPC) resources of the National Energy Research Scientific Computing Center (NERSC), a Department of Energy User Facility using NERSC award BES-ERCAP0032527. This work also used the HPC resources of the SLAC Shared Science Data Facility (S3DF) at SLAC National Accelerator Laboratory operated by Stanford University for the U.S. Department of Energy’s Office of Science. Work was also performed on the Carbon HPC cluster at the Center for Nanoscale Materials, a U.S. Department of Energy Office of Science User Facility, and was supported by the U.S. DOE, Office of Basic Energy Sciences, under Contract No. DE-AC02-06CH11357.
Keywords
Machine-learning interatomic potentials; Equivariant graph neural networks; Molecular dynamics; Heterogeneous catalysis; Scientific software; Uncertainty quantification
SI.pdf
Supporting Information
Installation
IANN requires Python 3.8 or newer and PyTorch 1.9 or newer. The package and its dependencies (numpy, ase, scipy, asap3, e3nn, toml, py-cpuinfo) are installed with
git clone https://github.com/changzhiai/IANN.git
cd IANN
pip install -e .
GPU support follows the standard PyTorch CUDA installation. e3nn is used for equivariant tensor algebra by default. The optional NVIDIA cuEquivariance[1] library can also be used to accelerate the equivariant tensor products, especially for NequIP and MACE. The LAMMPS interface additionally requires LibTorch (the PyTorch C++ API), CMake and a C++11 compiler; build instructions are given in the Documentation.
Framework implementation details
This section collects the implementation detail behind the framework overview of the manuscript, in the order the modules are described there. It documents the choices a reader may need in order to reproduce or extend it.
Graph construction and batching
Graph construction is handled by AseDataReader. Periodic systems use the linear-scaling cell-list neighbour list from asap3, non-periodic systems a direct distance-matrix cutoff; in both cases the reader returns edge indices together with the minimum-image edge vectors, and flags the edge vectors as requiring gradients when forces are needed. AseDataset wraps an ASE trajectory or database and reads structures lazily, so that datasets larger than memory are handled without a preprocessing step or a database conversion. Batching is performed by a collate function that concatenates the per-structure tensors, builds an image index that assigns every atom to its structure, and offsets the edge indices of each structure by the cumulative atom count, so that a batch is itself a single valid AtomsData object describing one disconnected graph.
Shared building blocks
Equivariant tensor algebra is provided by e3nn,[2] and the NequIP and MACE implementations transparently use NVIDIA’s cuEquivariance[1] kernels when the optional dependency is installed and chosen. Building blocks that are architecture-independent — the Bessel radial basis of the manuscript, the polynomial cutoff envelope, gated nonlinearities and activation functions — live in iann.tools and are shared.
Adding an architecture
Adding an architecture requires implementing a torch.nn.Module whose forward accepts and returns AtomsData and registering it in the model registry; the data pipeline, trainer, calculators and LAMMPS export are then inherited unchanged.
Trainer configuration
Trainer is configured by a single dictionary that is merged into a documented set of defaults (reproduced in full in the next section). It covers the architecture (num_channels, num_layers, cutoff, and architecture-specific keys such as , ), the objective (forces_weight, virial_weight, stress_weight, loss_per_atom), optimisation (optimizer_type, learning_rate, scheduler_type, max_grad_norm, max_steps or max_epochs, stop_patience), data handling (val_ratio, random_seed, save_split, load_split, norm_data, norm_per_atom), distributed execution and output. Adam, AdamW[3, 4] and SGD optimisers are available, together with seven learning-rate schedules selected by scheduler_type: LambdaLR (the default), ReduceLROnPlateau, CosineAnnealingLR, CosineAnnealingWarmRestarts, StepLR, MultiStepLR and ExponentialLR.[5]
Reproducibility safeguards in the trainer
Several decisions in the trainer exist specifically to remove recurring sources of error. Dataset splits can be written to and reloaded from a JSON file, so that a restarted or fine-tuned run provably reuses the original validation set. Energy statistics for normalisation are computed over the training split only, optionally from a random subsample and with threaded file I/O, which keeps the start-up cost of a multi-million-structure dataset bounded. For architectures that normalise messages by the mean coordination number, the average number of neighbours is measured from the training data automatically rather than being left as a user-supplied constant. Early stopping monitors an exponentially smoothed validation loss, which avoids terminating on a single noisy evaluation. Checkpoints store the architecture name and the complete set of architecture keyword arguments alongside the parameters, so that a model can be reconstructed exactly from the file alone; for older checkpoints that predate this convention, the loader infers the architecture from signatures in the parameter names. Restarts distinguish two intentions explicitly: resuming continues the step counter, optimiser state and schedule exactly, whereas fine-tuning (reset_lr) reloads the parameters but starts a fresh schedule at the requested learning rate.
Detecting the distributed environment
Distributed data-parallel training is enabled with distributed=True and configured by inspecting the environment. The trainer recognises SLURM (SLURM_PROCID, SLURM_NTASKS, SLURM_LOCALID) and the rank variables of OpenMPI, MPICH/Intel MPI and MVAPICH2, and from these derives the global rank, world size, per-node local rank and rendezvous address. PBS/Torque allocations are supported through the same path: PBS exports no rank variables of its own, so the ranks are read from whichever MPI launcher started the processes, while PBS_NODEFILE supplies the rendezvous host and the node list recorded in the log, deduplicated because PBS repeats each host once per requested core. The NCCL backend is selected on GPUs and Gloo on CPUs. On a bare multi-GPU node with no external launcher, the trainer spawns one worker process per visible GPU itself; under srun or mpirun it detects that the launcher has already created the processes and only reads its own coordinates. The practical consequence is that the training script of the manuscript is submitted unchanged on a laptop, a workstation and a multi-node allocation, with the job script alone determining the degree of parallelism.
Resolving and fine-tuning foundation models
A small selection ships inside the package and is resolved by name through foundation_model() irrespective of the working directory; the complete set is hosted separately. Any of them can be used as a zero-shot calculator or as the initialisation for fine-tuning, by passing the checkpoint path as load_model in the trainer configuration together with reset_lr to start a fresh learning-rate schedule.
Exporting a model to LAMMPS
For production MD, a trained model is compiled to TorchScript by convert_model_for_lammps, which wraps the model in a module whose forward takes only plain tensors — the same seven fields that define the graph — and returns a dictionary of energy, forces and atomic energies. Because that signature is architecture-independent, one wrapper and one exporter cover all models, and a companion function combines several checkpoints into a single ensemble module.
Agent interface
Command line. The package installs an iann entry point with nine subcommands — doctor, models, foundation, inspect, predict, train, status, export and agent — covering the operations of the layers above; doctor reports whether an environment can run IANN, and inspect which structural parameters a checkpoint does not record — the usual cause of a parameter-shape mismatch when a model is rebuilt from its weights. Every subcommand accepts --json, under which standard output carries nothing but the JSON document, and exit codes separate success from a failed operation and from a malformed command line, so a failure is never a traceback nor a silent empty result. Training requires an explicit step budget, because max_steps defaults to and a call that omitted one would begin a run lasting days.
MCP server. The same operations are served as nine tools over stdio by mcp_server, so that a client implementing the Model Context Protocol, and therefore a large-language-model agent, can call them without knowing how the framework is invoked. Both front ends call one implementation — a single function per operation, returning a plain dictionary — so the two cannot drift apart; the protocol SDK is an optional dependency, and the command line needs nothing beyond the base requirements.
Agent skills. iann agent install writes a set of repository notes and five skills into a working copy, recording what cannot be inferred from the source: which environment to use, that scripts are run from the repository root, and that a training run must be given a step budget. The notes are not specific to any one assistant. Job submission to SLURM or PBS, uploads to the model hub and deletion of files are not exposed at all, which confines an automated caller to reads and a bounded amount of local computation; the whole interface is contained in the iann.agent subpackage and documented in the Documentation.
Default trainer configuration
Table S1 lists the configuration keys recognised by iann.trainer.Trainer together with their defaults. Any subset can be overridden through the config dictionary passed to the constructor; keys that are not recognised by the trainer are forwarded to the model constructor, which is how architecture-specific parameters such as lmax, num_basis or parity are set.
| Key | Default | Meaning |
| Model | ||
num_channels | 128 | Feature channels per node |
num_layers | 3 | Message-passing layers |
cutoff | 5.5 | Cutoff radius (Å) |
| Objective | ||
forces_weight | 0.9 | Weight of the force term |
virial_weight | 0.0 | Weight of the virial term |
stress_weight | 0.0 | Weight of the stress term |
loss_per_atom | True | Divide the energy residual by the number of atoms |
| Optimisation | ||
optimizer_type | adam | adam, adamw or sgd |
learning_rate | 1e-4 | Initial learning rate |
| Key | Default | Meaning |
scheduler_type | LambdaLR | One of ReduceLROnPlateau, LambdaLR, CosineAnnealingLR, CosineAnnealingWarmRestarts, StepLR, MultiStepLR, ExponentialLR |
max_grad_norm | 10.0 | Gradient-norm clipping threshold |
batch_size | 12 | Structures per batch and per rank |
max_steps | 1000000 | Optimiser steps before stopping |
max_epochs | None | Alternative stopping criterion |
stop_patience | 200 | Evaluations without improvement before early stopping |
log_interval | 2000 | Steps between validation and logging |
| Data | ||
val_ratio | 0.1 | Fraction held out for validation |
random_seed | 666 | Seed for splitting and initialisation |
save_split | False | File name for storing the split |
load_split | False | File name of a split to reuse |
norm_data | False | Standardise energy targets |
norm_per_atom | False | Standardise per-atom energies |
norm_sample_size | None | Subsample size for the normalisation statistics |
norm_num_workers | 0 | Threads used to read the statistics |
| Restart | ||
load_model | False | Checkpoint path to resume or fine-tune from |
reset_lr | False | True: fresh schedule and step counter (fine-tuning); False: resume exactly |
| Distributed | ||
dist_timeout | 600 | Timeout of collective operations (s) |
master_port | 12356 | Rendezvous port |
| Output | ||
device | None | cpu or cuda; auto-detected if unset |
output_dir | output | Output directory |
output_log | output.log | Log file |
output_model | model.pt | Checkpoint file |
log_input | False | Echo the user configuration to the log |
debug | False | Verbose diagnostics |
Table S1. Configuration keys of iann.trainer.Trainer and their default values.
DFT databases
The DFT databases are collected and curated as shown in Table 1 in the manuscript, regrouped by exchange-correlation functional and converted to ASE trajectory format. The sources span three functionals: PBE for MPtrj, sAlex, OMat24, MatPES and OC22; RPBE for OC20 and OC25; and for the meta-GGA subsets of the Materials Project and MatPES. Note that a shared functional does not imply identical settings. For example, MPtrj, OMat24 and OC22 apply a Hubbard correction, the remaining PBE sources do not. OC25 has D3 dispersion corrections, OC20 does not. Outlier structures were removed from every source dataset based on abnormally high energy or force components, abnormally short interatomic distances, or the presence of overlapping atoms.
Foundation models details across architectures
Every architecture compared here is reimplemented within IANN against the shared AtomsData interface rather than taken from the authors’ released code, so the settings below are those of the IANN implementations and need not coincide with the ones published with the original models.
The configuration details of each architecture in the accuracy comparison of the manuscript are given in Table S2. The table lists the number of channels, the highest spherical harmonic degree and order , the number of message-passing layers, the total number of trainable parameters, the per-rank batch size, the initial learning rate and the gradient-norm clipping threshold. All runs used the curated MPtrj database (1,579,091 PBE structures), a cutoff of 5.5 Å, the Adam optimiser with the LambdaLR schedule, the per-atom energy loss and an early-stopping patience of 500 evaluations; all other keys retain the defaults of Table S1.
| Model | Channels | Layers | Parameters | Batch | LR | Clip | ||
| PaiNN* | 128 | 1 | 1 | 3 | 600,577 | 16 | 10.0 | |
| NequIP | 32 | 1 | 1 | 3 | 1,379,513 | 16 | 10.0 | |
| Allegro | 128 | 1 | 1 | 4 | 567,624 | 16 | 10.0 | |
| MACE | 48 | 1 | 1 | 3 | 1,429,376 | 16 | 10.0 | |
| EquiformerV2 | 16 | 4 | 2 | 3 | 773,089 | 8 | 10.0 | |
| EquiformerV3 | 32 | 3 | 2 | 3 | 943,249 | 16 | 10.0 | |
| UMA | 64 | 2 | 2 | 3 | 1,173,698 | 16 | 10.0 |
Table S2. Settings of the training of each architecture. is the highest spherical harmonic degree the features carry and the highest order kept at each degree; NequIP, MACE and Allegro build full irreps, so , whereas the Equiformers truncate below to cut the cost of the convolution. *Equivalent values: PaiNN exposes neither setting, but its Cartesian scalars and vectors are equivariant to with all orders present.
EquiformerV2 additionally used grid_resolution=12 and avg_degree=43.0; UMA used hidden_channels=64, edge_channels=64 and num_distance_basis=128. All architectures except PaiNN were trained with per-atom energy standardisation (norm_per_atom=True), with the statistics estimated from a random subsample of 5000 training frames (norm_sample_size). For MACE, NequIP and Allegro the trainer measured the average number of neighbours from the training data automatically.
Foundation model details across datasets
Table S3: Accuracy of the released PaiNN foundation models. Energies are per atom; forces are per Angstrom. and count the structures and atoms entering each fit.
| Dataset | Energy (eV atom) | Force (eV Å) | ||||
| MAE | MAE | |||||
| PBE | ||||||
| Alexandria | 10,422,893 | 107,451,444 | 0.0408 | 0.9988 | 0.0513 | 0.9512 |
| MatPES | 434,083 | 3,865,201 | 0.0463 | 0.9984 | 0.0930 | 0.9583 |
| MPtrj | 1,579,058 | 49,229,839 | 0.0517 | 0.9980 | 0.0498 | 0.9767 |
| OC22 | 8,198,695 | 654,300,266 | 0.0381 | 0.9986 | 0.0528 | 0.8373 |
| OMat24 | 11,261,400 | 156,856,550 | 0.0261 | 0.9991 | 0.1382 | 0.9961 |
| RPBE | ||||||
| OC20 | 1,999,216 | 146,438,327 | 0.0263 | 0.9997 | 0.0630 | 0.9422 |
| OC25 | 7,369,601 | 1,064,203,162 | 0.0116 | 0.9998 | 0.0753 | 0.9864 |
| SCAN | ||||||
| MatPES | 387,285 | 3,039,030 | 0.0446 | 0.9999 | 0.1127 | 0.9507 |
| MPtrj | 238,241 | 5,022,951 | 0.0206 | 0.9999 | 0.0117 | 0.9710 |
Table S3.
Parity plots for the foundation models
Figure S1–S9 give fitting parity plots of energy and forces between each foundation model and its DFT reference data, one figure per released model in the order of Table 3 in the manuscript. The colorbar shows the number of structures in each bin, and the dashed line is the diagonal. The details of the training databases and the full error statistics are given in Table S3 of the next section.

Figure S1. Energy and force parity plots between the prediction of the PBE-MPtrj foundation model and the DFT reference.

Figure S2. Energy and force parity plots between the prediction of the PBE-sAlex foundation model and the DFT reference.

Figure S3. Energy and force parity plots between the prediction of the PBE-OMat24 foundation model and the DFT reference.

Figure S4. Energy and force parity plots between the prediction of the PBE-MatPES foundation model and the DFT reference.

Figure S5. Energy and force parity plots between the prediction of the PBE-OC22 foundation model and the DFT reference.

Figure S6. Energy and force parity plots between the prediction of the RPBE-OC20 foundation model and the DFT reference.

Figure S7. Energy and force parity plots between the prediction of the RPBE-OC25 foundation model and the DFT reference.

Figure S8. Energy and force parity plots between the prediction of the SCAN-MP foundation model and the DFT reference.

Figure S9. Energy and force parity plots between the prediction of the SCAN-MatPES foundation model and the DFT reference.
Fine-tuning details
Table S4 gives the full series behind the full-budget comparison. Training was performed on the same train set of 24,154 structures from the AdsTraj training set, evaluated throughout on the same test set of 7,296 structures. The zero-shot row is the error of the RPBE-OC20 foundation model on the test set, without any fine-tuning. The “from scratch” rows are the errors of models trained from random initialisation on the indicated number of training structures, and the “fine-tuned” rows are the errors of the same model after fine-tuning from RPBE-OC20 on the same number of training structures. The final row is the same as Table 4 in the manuscript.
Training cost

Figure S10. Cost of training measured on the same V100 as inference. (a) Wall time per optimizer step against batch size, in 108-atom cells. (b) Training throughput in structures per second, and where it saturates. (c) Peak GPU memory versus batch size. (d) One training step against one inference call on the same cell. The corresponding numbers are in Table S5.
| Architecture | step (ms) | struct./s | GPU-h per steps | mem (GiB) | step at (ms) | vs inference | |
| PaiNN | 16 | 86.0 | 186 | 23.9 | 3.8 | 86.0 | 2.8× |
| NequIP | 16 | 110.1 | 145 | 30.6 | 2.0 | 110.1 | 2.2× |
| Allegro | 16 | 935.4 | 17 | 259.8 | 10.9 | 935.4 | 2.8× |
| MACE | 16 | 91.3 | 175 | 25.4 | 2.7 | 91.3 | 2.5× |
| EquiformerV2 | 8 | 824.9 | 10 | 229.1 | 19.9 | 1649.8 | 2.4× |
| EquiformerV3 | 16 | 919.1 | 17 | 255.3 | 25.5 | 919.1 | 2.6× |
| UMA | 16 | 515.4 | 31 | 143.2 | 16.7 | 515.4 | 3.0× |
Table S5. Table S5: Cost and corresponding details of all architectures trained on Tesla V100 GPU.
Inference cost
Table S8. DFT calculations on CPUs: VASP 6.3.2 single points on the same Pt(111)+CO cells, RPBE, cutoff with 450 eV, and 64 MPI ranks on one node.
| Atoms | LOOP+ (s) | SCF steps | s per SCF step |
| 18 | 2.5 | 35 | 0.07 |
| 38 | 8.3 | 39 | 0.21 |
| 66 | 21.7 | 38 | 0.57 |
| 102 | 63.3 | 45 | 1.41 |
| 146 | 149.7 | 43 | 3.48 |
caption:

Figure S11. The wall time consumption in an energy+forces call with same models and hardware as Figure 6 in the manuscript. (a) Share of each call spent building the neighbour list against system size. (b) Throughput against batch size at a fixed 108-atom cell. (c) Cost against the number of edges in the graph at the 5.5 Å cutoff for two geometries: bulk fcc Pt at 42 edges per atom (filled) and the Pt(111) slab at 33 (open), whose surface atoms are missing a quarter of their neighbours. (d) Ratio of CPU to GPU wall time, per architecture and per size.

Figure S12. Energy-only inference versus energy+forces inference. (a) Time per energy-only call against system size, timed under no autograd graph is built. (b) Forces cost, as the ratio of the two timing modes. (c) Peak GPU memory in both modes. Solid is for the energy+forces mode and open is for the energy-only mode. (d) Throughput in the two modes against each other. The corresponding numbers are in Table S7.
Table S7. Energy-only inference against energy+forces. Energy-only is timed under no autograd graph retained.
| Architecture | Floor (ms) | Crossover (s/atom) | Floor (ms) | Crossover (s/atom) | Force cost, Floor | Force cost, Crossover | Mem (GiB) | Mem (GiB) |
| PaiNN | 3.1 | 6.9 | 9.0 | 15.9 | 2.90× | 2.30× | 0.33 | 1.36 |
| NequIP | 6.7 | 5.5 | 24.3 | 18.5 | 3.61× | 3.33× | 0.29 | 0.92 |
| Allegro | 4.5 | 54.3 | 19.1 | 180.7 | 4.28× | 3.33× | 1.07 | 5.72 |
| MACE | 8.2 | 5.5 | 20.8 | 15.0 | 2.55× | 2.72× | 0.21 | 0.76 |
| EquiformerV2 | 39.0 | 95.5 | 114.6 | 306.7 | 2.94× | 3.21× | 7.73 | 19.77 |
| EquiformerV3 | 19.3 | 58.9 | 53.6 | 171.6 | 2.78× | 2.91× | 2.07 | 13.28 |
| UMA | 11.1 | 39.3 | 28.4 | 91.4 | 2.57× | 2.33× | 0.70 | 4.32 |
caption:
Parallel training details
Table S9: Training efficiency of different architectures on MPtrj on 1 to 16 NVIDIA A100-SXM4-80GB GPUs. is each run’s own per-rank batch size, so the global batch is and the work per GPU is fixed; is the global throughput in structures per second and the efficiency is . The all-reduce column is the part of the gradient reduction that is not hidden behind the backward pass.
| Architecture | per rank | Global at | (struct./s) | (struct./s) | Speedup | Efficiency (%) | All-reduce (% step) | Mem/GPU (GiB) |
| PaiNN | 16 | 256 | 305.4 | 3892.5 | 12.75 | 79.7 ± 0.7 | 19.5 | 3.22 |
| NequIP | 16 | 256 | 218.6 | 2919.7 | 13.36 | 83.6 ± 0.2 | 8.1 | 1.62 |
| Allegro | 16 | 256 | 70.3 | 756.5 | 10.77 | 67.3 ± 1.0 | 41.1 | 9.24 |
| MACE | 16 | 256 | 208.8 | 2869.0 | 13.74 | 86.0 ± 0.5 | 7.5 | 2.17 |
| EquiformerV2 | 8 | 128 | 30.8 | 323.2 | 10.50 | 65.7 ± 1.6 | 43.2 | 24.27 |
| EquiformerV3 | 16 | 256 | 61.3 | 727.5 | 11.86 | 74.1 ± 0.3 | 29.1 | 19.99 |
| UMA | 16 | 256 | 95.4 | 1082.1 | 11.34 | 71.1 ± 0.4 | 37.2 | 12.75 |
Table S9. Training efficiency of different architectures on MPtrj on 1 to 16 NVIDIA A100-SXM4-80GB GPUs.
Table S10: Training global throughput in structures per second, and parallel efficiency , at every allocation from 1 to 16 A100 GPUs. is the per-rank batch size, so the global batch at each column is . Every world size times an identical set of structures.
| Architecture | \multicolumn{5}{c | }{ (structures s)} | \multicolumn{4}{c | }{Parallel efficiency (%) } | ||||||
| 1 | 2 | 4 | 8 | 16 | 2 | 4 | 8 | 16 | ||
| PaiNN | 16 | 305 | 577 | 1106 | 2042 | 3892 | 94.3 | 90.5 | 83.5 | 79.7 |
| NequIP | 16 | 219 | 431 | 798 | 1509 | 2920 | 98.5 | 91.3 | 86.5 | 83.6 |
| Allegro | 16 | 70 | 118 | 223 | 410 | 756 | 84.4 | 79.7 | 73.0 | 67.3 |
| MACE | 16 | 209 | 409 | 775 | 1470 | 2869 | 98.0 | 92.8 | 88.1 | 86.0 |
| EquiformerV2 | 8 | 31 | 55 | 98 | 176 | 323 | 89.0 | 79.5 | 71.3 | 65.7 |
| EquiformerV3 | 16 | 61 | 113 | 209 | 385 | 727 | 91.9 | 85.0 | 78.5 | 74.1 |
| UMA | 16 | 95 | 174 | 316 | 575 | 1082 | 91.4 | 82.8 | 75.4 | 71.1 |
Table S10. Training global throughput in structures per second, and parallel efficiency , at every allocation from 1 to 16 A100 GPUs.
Parallel inference details
Table S11: The performance of the IANN LAMMPS interface of pair_style iann/multi_gpu on NVIDIA A100-80GB GPUs in Figure 7 in the manuscript is tabulated here. The step time per step on 1 to 8 GPUs, the corresponding efficiencies derived from them, and the throughput at eight GPUs are listed at each system size. For 8 GPUs, four GPUs sit in one node (NVLink), and eight span two (Slingshot). The last column is the exact serial run of LAMMPS interface with pair_style iann on a single GPU.
oom: CUDA out of memory on the 80 GB device – measured, not inferred, and reproduced in all three repeats.
n/a: not defined, because the run it would be derived from oomed. ‡P: this size does not fit on one GPU, so its efficiencies are referenced to GPUs rather than one. Every entry is the median of three independent jobs. Runs use PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True and a warm-up run before each timed run; without these the large cells are 16–29% slower and their efficiencies correspondingly overestimated. is the wall-clock step time. The model-evaluation component alone scales smoothly at every size.
Distributed submission scripts
The parallelization training submission script on a SLURM machine with four GPUs per node:
#!/bin/bash
#SBATCH -N 2
#SBATCH -C gpu
#SBATCH -q regular
#SBATCH -t 04:00:00
#SBATCH --gpus-per-node=4
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=32
export GPUS_PER_NODE=$SLURM_GPUS_ON_NODE
export NNODES=$SLURM_NNODES
srun -N $NNODES -n $((NNODES*GPUS_PER_NODE)) python train.py
Rank, world size, per-node local rank and the rendezvous address are read from the scheduler environment by the trainer. Under PBS with mpirun, the first host of $PBS_NODEFILE is used as the rendezvous address unless MASTER_ADDR is exported explicitly and forwarded to every rank.
LAMMPS interface
A trained checkpoint is compiled to TorchScript with:
from iann.plugins.converter import convert_model_for_lammps
convert_model_for_lammps(model_path="output/model.pt",
output_path="model_lmp.pt")
Several checkpoints are combined into one ensemble module with convert_models_for_lammps. The model type is read from the checkpoint metadata and does not have to be supplied. The exported file is used in a LAMMPS input script as:
units metal
atom_style atomic
boundary p p p
read_data initial.data
pair_style iann painn model_lmp.pt 5.5
pair_coeff * *
neighbor 0.5 bin
neigh_modify every 1 delay 0 check yes
compute variance all iann/variance
thermo_style custom step pe ke etotal temp press &
c_variance[1] c_variance[2] c_variance[3] c_variance[4]
thermo 100
timestep 0.001
fix 1 all nvt temp 300.0 300.0 0.1
run 100000
where the four components of c_variance are the mean energy variance, the mean force variance, the maximum energy variance and the maximum force variance over the ensemble. Replacing pair_style iann by pair_style iann/multi_gpu assigns one GPU to each MPI rank, so that device placement follows the LAMMPS domain decomposition.
Uncertainty quantification
from iann.calculators import AtomicEnsembleCalculator
calc = AtomicEnsembleCalculator(
model_paths=["m1.pt", "m2.pt", "m3.pt"], device="cuda")
atoms.calc = calc
energy = atoms.get_potential_energy()
unc = calc.get_ensemble()
print(unc["energy_var"], unc["atomic_energy_var"])
EnsembleCalculator returns not only average energy and forces but also the variance of the total energy and of the forces; AtomicEnsembleCalculator additionally returns the variance of the per-atom energy decomposition, which localises the uncertainty on individual atoms.
Appendix: Periodic-table statistics for each database
Figure S14–Figure S49 repeat the element-resolved maps for each source database on its own, using the model trained on that database alone.

Figure S14. PBE-MPtrj: number of structures containing each element. 1,579,091 structures, 49,231,714 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S49. r2SCAN-MatPES: per-element force MAE () of the model trained on this database alone, which reaches 0.1129 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S15. PBE-MPtrj: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S16. PBE-MPtrj: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0517 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S17. PBE-MPtrj: per-element force MAE (eV/) of the model trained on this database alone, which reaches 0.0498 eV/ overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S18. PBE-sAlex: number of structures containing each element. 10,423,284 structures, 107,455,806 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S19. PBE-sAlex: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S20. PBE-sAlex: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0408 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S21. PBE-sAlex: per-element force MAE (eV/) of the model trained on this database alone, which reaches 0.0513 eV/ overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure 22. PBE-OMat24: number of structures containing each element. 11,274,650 structures, 157,069,839 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure 23. PBE-OMat24: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S24. PBE-OMat24: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0264 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S25. PBE-OMat24: per-element force MAE (eV/Å) of the model trained on this database alone, which reaches 0.1391 eV/Å overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S26. PBE-MatPES: number of structures containing each element. 434,092 structures, 3,865,819 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S27. PBE-MatPES: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S28. PBE-MatPES: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0463 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S29. PBE-MatPES: per-element force MAE (eV/Å) of the model trained on this database alone, which reaches 0.0930 eV/Å overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S30. PBE-OC22: number of structures containing each element. 8,199,197 structures, 654,340,594 atoms, 57 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S31. PBE-OC22: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S32. PBE-OC22: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0381 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S33. PBE-OC22: per-element force MAE (eV/) of the model trained on this database alone, which reaches 0.0528 eV/ overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S34. RPBE-OC20: number of structures containing each element. 1,999,572 structures, 146,467,030 atoms, 56 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S35. RPBE-OC20: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S36. RPBE-OC20: per-element energy MAE () of the model trained on this database alone, which reaches 0.0263 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S37. RPBE-OC20: per-element force MAE () of the model trained on this database alone, which reaches 0.0630 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S38. RPBE-OC25: number of structures containing each element. 7,370,461 structures, 1,064,330,294 atoms, 73 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S39. RPBE-OC25: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S40. RPBE-OC25: per-element energy MAE () of the model trained on this database alone, which reaches 0.0116 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S41. RPBE-OC25: per-element force MAE () of the model trained on this database alone, which reaches 0.0753 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S42. r2SCAN-MPtrj: number of structures containing each element. 238,241 structures, 5,022,951 atoms, 88 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.

Figure S43. r2SCAN-MPtrj: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S44. r2SCAN-MPtrj: per-element energy MAE (eV/atom) of the model trained on this database alone, which reaches 0.0206 eV/atom overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S45. r2SCAN-MPtrj: per-element force MAE (eV/) of the model trained on this database alone, which reaches 0.0117 eV/ overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S46. r2SCAN-MatPES: number of structures containing each element. 387,306 structures, 3,040,410 atoms, 89 elements. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S47. r2SCAN-MatPES: total number of atoms of each element. A structure with many atoms of one element counts once in the map above and once per atom here, so the two differ wherever the stoichiometry is skewed. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
Figure S48. r2SCAN-MatPES: per-element energy MAE () of the model trained on this database alone, which reaches 0.0446 overall. Color scales are shared across the databases of a functional, so tiles are directly comparable between the maps of this appendix.
References
- [1]NVIDIA, cuEquivariance: GPU-accelerated primitives for equivariant neural networks, https: //github.com/NVIDIA/cuEquivariance, 2025.
- [2]M. Geiger, T. Smidt, e3nn: Euclidean neural networks, arXiv:2207.09453, 2022.arxiv.org/abs/2207.09453
- [3]D. P. Kingma, J. Ba in International Conference on Learning Representations, 2015.
- [4]I. Loshchilov, F. Hutter in International Conference on Learning Representations, 2019.
- [5]I. Loshchilov, F. Hutter in International Conference on Learning Representations, 2017.






