fairchem is the FAIR Chemistry's centralized repository of all its data, models,
demos, and application efforts for materials science and quantum chemistry.
Uma-nitro brings blazing speedups to UMA. Currently it is only supported on Nvidia Ampere GPUs and above. Speed is heavily optimized on Hopper series and above for single-gpu single-system mode. On unsupported GPU types, the system will fallback to other non-nitro modes. Stay tuned as we bring nitro support for multi-gpu and batch modes. In the sub 5-10 ms/step regime, ASE integrators starts to become a bottleneck. To achieve the true performance capabilities of these models, we recommend moving to non-python/GPU based integrators.
The vertical axis is force MAE (meV/Å) on the public OMol25 validation set; the horizontal axis is MD speed (ns/day at a 1 fs timestep) from the mean runtime of an ASE NVE step on a 1000-atom silicon cell using an NVIDIA H200. See the benchmark details and reproduction scripts for the full setup.
For more OMol model accuracy benchmarks, you can also see the FAIR Chemistry leaderboard.
Please use this logo for references to UMA!
- UMA Nitro, the new default inference mode, is much faster than turbo for molecular dynamics and relaxations on a single GPU. On a single NVIDIA H200, it reaches ~6 ns/day for 1,000 atoms in ASE MD and raw inference throughput equivalent to ~33 ns/day for 150 atoms, with support for systems up to 15,000 atoms. Special thanks to Emanuele Arcelli and Max Zhdanov (for their FlashUMA work), Carole-Jean Wu, Christian Puhrsch, Zachary DeVito, Aditya Venkataraman, Michael Lazos, and Animesh Jain, all of whom contributed to and helped improve UMA Nitro. See UMA Nitro.
- Two new UMA-S-1.2.1 models:
uma-s-1p2p1-ft-d4revfor molecules (ωB97M-D4rev) anduma-s-1p2p1-ft-r2scanfor materials (r²SCAN, trained on MAD-1.6). These improve a wide range of observables compared to experiments. Please be aware of their limitations. - DFT-D3(BJ) dispersion (including GPU support) for any ASE calculator, with PBE and r²SCAN presets. These make the respective materials tasks significantly more transferable outside of solid-state systems. See D3 dispersion corrections.
Read our new paper on quantum-accurate atomistic modeling of enzyme catalysis using a machine-learned potential.
UMA playground released, try the interactive educational demo here yourself!
UMA-1.2 released! ~50% faster, ~40% more accurate on Open Molecules test set, and expanded data coverage for catalysts (oxides and interfaces), molecules, and polymers!
check out our seamless Multi-node, Multi-GPU and LAMMPs interfaces to run large scale dynamics!
UMA/OMol first released! Read about the UMA model and OMol25 dataset release.
Although not required, we highly recommend installing using a package manager and virtualenv such as uv, it is much faster and better at resolving dependencies than standalone pip.
Install fairchem-core using pip
pip install fairchem-coreIf you want to contribute or make modifications to the code, clone the repo and install in edit mode
git clone git@github.com:facebookresearch/fairchem.git
pip install -e fairchem/packages/fairchem-core[dev]The easiest way to use pretrained models is via the ASE FAIRChemCalculator.
A single uma model can be used for a wide range of applications in chemistry and materials science by picking the
appropriate task name for domain specific prediction.
Make sure you have a Hugging Face account, have already applied for model access to the UMA model repository, and have logged in to Hugging Face using an access token. You can use the following to save an auth token,
huggingface-cli loginModels are referenced by their name, below are the currently supported models:
| Model Name | Description |
|---|---|
| uma-s-1p2p1 | Latest version of the UMA small model, fastest of the UMA models while still SOTA on most benchmarks (6.6M/290M active/total params) |
| uma-s-1p2p1-ft-d4rev | UMA-S-1.2.1 fine-tuned to ωB97M-D4rev for molecular systems; omol task only. See new models |
| uma-s-1p2p1-ft-r2scan | UMA-S-1.2.1 fine-tuned on r²SCAN data (MAD-1.6) for inorganic materials and beyond; omat task only, not spin-polarized. See new models |
| uma-m-1p1 | Best in class UMA model across all metrics, but slower and more memory intensive than uma-s (50M/1.4B active/total params) |
- oc20: use this for catalysis
- oc22: use this for oxide catalysis (>1p2)
- oc25: use this for (electro)catalysis (>1p2)
- omat: use this for inorganic materials
- omol: use this for molecules+polymers
- odac: use this for MOFs
- omc: use this for molecular crystals
from ase.build import fcc100, add_adsorbate, molecule
from ase.optimize import LBFGS
from fairchem.core import pretrained_mlip, FAIRChemCalculator
predictor = pretrained_mlip.get_predict_unit("uma-s-1p2p1", device="cuda")
calc = FAIRChemCalculator(predictor, task_name="oc20")
# Set up your system as an ASE atoms object
slab = fcc100("Cu", (3, 3, 3), vacuum=8, periodic=True)
adsorbate = molecule("CO")
add_adsorbate(slab, adsorbate, 2.0, "bridge")
slab.calc = calc
# Set up LBFGS dynamics object
opt = LBFGS(slab)
opt.run(0.05, 100)from ase.build import bulk
from ase.optimize import FIRE
from ase.filters import FrechetCellFilter
from fairchem.core import pretrained_mlip, FAIRChemCalculator
predictor = pretrained_mlip.get_predict_unit("uma-s-1p2p1", device="cuda")
calc = FAIRChemCalculator(predictor, task_name="omat")
atoms = bulk("Fe")
atoms.calc = calc
opt = FIRE(FrechetCellFilter(atoms))
opt.run(0.05, 100)Warning
Materials Project and OMat24 DFT settings: OMat24-trained UMA and legacy inorganic models use DFT and DFT+U total-energy labels that are not compatible with Materials Project calculations. Use the OMat24 reference unary compounds and MP2020-style anion and GGA/GGA+U mixing corrections from the OMat24 Hugging Face repository. Do not apply Materials Project reference compounds or MP2020 corrections directly. Take care when comparing formation energies or energies above hull with Materials Project results: pseudopotentials differ, and magnetic ground states may differ as well.
Note: pretrained_mlip.get_predict_unit() currently uses a seed to set the global state of the numpy RNG. In order to obtain different trajectories for different runs of the following code, we have to set a random seed as shown below:
import numpy as np
from ase import units
from ase.io import Trajectory
from ase.md.langevin import Langevin
from ase.build import molecule
from fairchem.core import pretrained_mlip, FAIRChemCalculator
seed = np.random.randint(0, np.iinfo(np.int32).max, dtype=int)
# the default inference mode (nitro) is the fastest for MD on a single GPU
predictor = pretrained_mlip.get_predict_unit("uma-s-1p2p1", device="cuda", seed=seed)
calc = FAIRChemCalculator(predictor, task_name="omol")
atoms = molecule("H2O")
atoms.calc = calc
dyn = Langevin(
atoms,
timestep=0.1 * units.fs,
temperature_K=300,
friction=0.001 / units.fs,
)
trajectory = Trajectory("my_md.traj", "w", atoms)
dyn.attach(trajectory.write, interval=1)
dyn.run(steps=1000)from ase.build import molecule
from fairchem.core import pretrained_mlip, FAIRChemCalculator
predictor = pretrained_mlip.get_predict_unit("uma-s-1p2p1", device="cuda")
# singlet CH2
singlet = molecule("CH2_s1A1d")
singlet.info.update({"spin": 1, "charge": 0})
singlet.calc = FAIRChemCalculator(predictor, task_name="omol")
# triplet CH2
triplet = molecule("CH2_s3B1d")
triplet.info.update({"spin": 3, "charge": 0})
triplet.calc = FAIRChemCalculator(predictor, task_name="omol")
triplet.get_potential_energy() - singlet.get_potential_energy()DFTD3Calculator adds GPU-accelerated DFT-D3(BJ) energies, forces and analytic stresses (via nvalchemiops) to any
ASE calculator. For example, use functional="pbe" for PBE-trained heads and functional="r2scan" for uma-s-1p2p1-ft-r2scan.
from fairchem.core import DFTD3Calculator, FAIRChemCalculator, pretrained_mlip
predictor = pretrained_mlip.get_predict_unit("uma-s-1p2p1", device="cuda")
calc = DFTD3Calculator(
FAIRChemCalculator(predictor, task_name="omat"), functional="pbe", device="cuda"
)See the D3 docs for the parameters and references.
If you have multiple gpus (or multiple nodes), we handle all the parallelism for you under the hood by a single flag (workers=N). Use inference_settings="multigpu" (formerly turbo) with workers > 1, since the default (nitro) runs on a single GPU. This is also compatible with LAMMPs to perform large scale MD. See our docs for more details. This requires the Ray package to be installed and comes with the extras bundle.
pip install fairchem-core[extras]
import time
import numpy as np
from ase import units
from ase.md.langevin import Langevin
from fairchem.core import pretrained_mlip, FAIRChemCalculator
from fairchem.core.datasets.common_structures import get_fcc_crystal_by_num_atoms
seed = np.random.randint(0, np.iinfo(np.int32).max, dtype=int)
predictor = pretrained_mlip.get_predict_unit(
"uma-s-1p2p1",
inference_settings="multigpu",
device="cuda",
workers=8,
seed=seed,
)
calc = FAIRChemCalculator(predictor, task_name="omat")
atoms = get_fcc_crystal_by_num_atoms(8000)
atoms.calc = calc
dyn = Langevin(
atoms,
timestep=0.1 * units.fs,
temperature_K=300,
friction=0.001 / units.fs,
)
# warmup 10 steps
dyn.run(steps=10)
start_time = time.time()
dyn.attach(
lambda: print(
f"Step: {dyn.get_number_of_steps()}, E: {atoms.get_potential_energy():.3f} eV, "
f"QPS: {dyn.get_number_of_steps()/(time.time()-start_time):.2f}"
),
interval=1,
)
dyn.run(steps=1000)fairchem is available under a MIT License. Models/checkpoint licenses vary by application area.