DPA4C-OMol25-100M

DPA4C-OMol25-100M provides a series of DPA4C machine-learning interatomic potentials trained on the OMol25 100M split. DPA4C is the compact, compressible member of the DPA4 family. The models are conservative, span the full periodic table, and are intended for molecular systems within the chemical space covered by OMol25. Each local environment is read once, there is no message-passing state, and the compressed CUDA path replaces the analytic radial functions with tabulated splines.

Overview

General information:

Item	Value
Architecture	DPA4C
Backend	PyTorch Exportable (dp --pt-expt)
Precision	float32
Elements	Full periodic table (H–Og)
Cutoff radius	6.0 Å
Training data	OMol25 100M (101,666,280 frames)
Validation data	OMol25 (2,762,021 frames)
Trained with	DeePMD-kit 3.2.0, PyTorch 2.11 / CUDA 12.8

Released files:

A release is identified by a date-based <version> carried in the file name, so additional sizes or re-trained checkpoints of an existing size can be published alongside earlier ones. Each release provides, for every variant, a checkpoint and its training configuration:

File	Description
DPA4C-<Variant>-OMol25-100M-<version>.pt	Model checkpoint.
DPA4C-<Variant>-OMol25-100M-<version>.json	Training configuration.

Architecture, hyperparameters, and parameter counts are in the released .json. The architecture is described in the DeePMD-kit DPA4C documentation.

The models predict atomic energies, from which forces are obtained by differentiation:

$\qquad \mathbf{F}_i = -\frac{\partial E}{\partial \mathbf{r}_i}$

The descriptor is one-hop local: an atom's features depend only on neighbors within rcut. Frame-level total charge and spin multiplicity condition the descriptor through FiLM.

Validation

Results on the OMol25 OMol-0 out-of-distribution composition validation split. Energy and force are MAEs. Lower errors and lower training cost are preferred.

Model	Energyᵃ	Forceᵃ	Params	Training hoursᵇ
eSEN-sm-cons.	1.77	0.190	6.3M	–
MACE-OMol-L-0	4.56	0.250	–	–
DPA4-Nano	8.02	0.776	0.480M	283.2
DPA4-Mini	4.97	0.502	0.655M	656.3
DPA4C series
DPA4C-Nano	40.97	2.485	0.035M	33.6
DPA4C-Mini	28.58	1.881	0.200M	56.7
DPA4C-Neo	24.74	1.731	0.539M	91.2
DPA4C-Air	21.37	1.597	0.630M	142.1
DPA4C-Plus	16.77	1.383	2.189M	340.9

• ᵃ Mean absolute errors: kcal/mol for total energy, kcal/mol/Å for forces. Values originally reported in meV and meV/Å are converted with 1 meV = 0.0230605 kcal/mol.
• ᵇ Total training cost in H20 GPU-hours. A dash means no comparable total is available.

Usage

DPA4C runs on the PyTorch Exportable backend (dp --pt-expt). Export uses .pt2 (AOTInductor). Usage follows the DeePMD-kit DPA4C documentation. In the commands below, replace <version> with the release date and <Variant> with the model variant.

Installation

DPA4C is available in the DeePMD-kit main branch (version 3.2.0). Add the official install skill and let an agent perform the installation:

npx -y skills add https://github.com/deepmodeling/deepmd-kit/tree/master/skills --skill deepmd-install -y

For offline or backend-specific installation, see the DeePMD-kit installation guide. Compression and the fused CUDA inference path require CUDA.

Evaluate a checkpoint

dp --pt-expt test -m DPA4C-<Variant>-OMol25-100M-<version>.pt -s /path/to/test/system -n 1000

Freeze and compress for deployment

Compression is the deployment step. It replaces the analytic radial functions and their type-pair modulation with tabulated splines evaluated by fused CUDA kernels, and re-exports the model in the compact canonical graph form that the fast inference path consumes. Because the radial map is analytically bounded and vanishes at rcut, the table needs no extrapolation region and no overflow checking.

Freeze the released checkpoint, then compress the frozen archive:

dp --pt-expt freeze -c DPA4C-<Variant>-OMol25-100M-<version>.pt -o frozen_model --lower-kind graph
dp --pt-expt compress -i frozen_model.pt2 -o compressed_model.pt2

The two archives are not interchangeable. frozen_model.pt2 carries the plain graph lower and is the uncompressed intermediate; compressed_model.pt2 carries the compact canonical graph lower and is what you deploy. Compression selects that lower on its own, so it takes no lower-kind option of its own.

Only -s, --step applies to DPA4C; it sets the uniform spline spacing in Å, and a smaller value means a finer table and a larger model.

The .pt2 is an AOTInductor archive and is target-specific. Freeze and compress on the target machine rather than reusing a .pt2 across different hardware.

Compression requires the PyTorch Exportable backend on CUDA, precision: "float32", and channels / lmax / radial_modes inside the compiled sets listed under Intended use and limitations. All released sizes satisfy these constraints.

Inference settings

Inference behavior is controlled by environment variables read when the model is constructed. Set them before running dp --pt-expt freeze or dp --pt-expt compress. The exported .pt2 is an AOTInductor artifact, so the precision policy is captured into the graph at export time and is not re-evaluated when the .pt2 is later loaded by LAMMPS or ASE.

Environment variable	Default	Effect
DP_AMP_INFER	off	bf16 autocast over the per-edge stage during inference. Independent of the training-time use_amp.
DP_TF32_INFER	0	float32 matmul precision: 0 highest, 1 high, 2 medium.

For molecular dynamics sensitive to the smoothness of the potential energy surface, keep DP_TF32_INFER=0 and DP_AMP_INFER=0.

Run in LAMMPS

DPA4C uses the PyTorch .pt2 export path and is served by the deepmd pair style:

atom_modify map yes
pair_style  deepmd compressed_model.pt2
pair_coeff  * * O H

atom_modify map yes is required: .pt2 graph inference relies on an explicit ghost/periodic-image to local-atom map, and the Kokkos pair style fails fast if the map is absent. Keep the type_map order consistent across the released input file and the pair_coeff mapping.

The compact canonical graph form exists so that the whole step can stay on the device. Only the Kokkos pair styles use that device-resident entry point; the host styles run the same archive through a per-step host round trip. Reaching DPA4C's advertised throughput therefore takes a Kokkos-enabled LAMMPS build on the GPU backend together with the compressed archive. Compression already enables the fused CUDA path.

Pair style	Build	Accepted archive	Execution
deepmd	any	graph lower or compressed	host round trip each step
deepmd/kk	Kokkos, GPU backend only	graph lower or compressed	device-resident; compressed uses fused kernels

Run under Kokkos with one GPU:

lmp -k on g 1 -sf kk -in in.lammps

Because DPA4C performs no message passing, it needs no cross-rank halo exchange of intermediate features, and MPI domain decomposition follows the ordinary pair-style path. Launch one MPI rank per GPU and make every target device visible:

CUDA_VISIBLE_DEVICES=0,1,2,3 mpirun -np 4 lmp -k on g 1 -sf kk -in in.lammps

Use a non-zero neighbor skin, for example neighbor 2.0 bin, to keep per-step GPU memory stable; a zero skin rebuilds the neighbor list every step.

Run with ASE

OMol-style models read the frame-level total charge and spin multiplicity from atoms.info["charge_spin"]. If the field is omitted, the model uses the default [0, 1] (neutral singlet).

import numpy as np
from ase.build import molecule
from deepmd.calculator import DP

atoms = molecule("CH2_s1A1d")
atoms.info.update({"charge_spin": np.array([0, 1])})
atoms.calc = DP(model="DPA4C-<Variant>-OMol25-100M-<version>.pt")

energy = atoms.get_potential_energy()
forces = atoms.get_forces()

Set the field to the physical charge and multiplicity of the system:

# neutral singlet
atoms.info.update({"charge_spin": np.array([0, 1])})

# cation doublet
atoms.info.update({"charge_spin": np.array([1, 2])})

# anion singlet
atoms.info.update({"charge_spin": np.array([-1, 1])})

Fine-tune on a downstream dataset

Start from the corresponding released input file and keep the entire model section unchanged — descriptor, fitting net, the full-periodic-table type_map, and the charge/spin conditioning. Replace only the training/validation data and use a small learning rate (e.g. start_lr = 1e-4):

dp --pt-expt train input_finetune.json --finetune DPA4C-<Variant>-OMol25-100M-<version>.pt

Intended use and limitations

• Intended for energy and force prediction of molecular systems within the chemistry and configuration space covered by OMol25, including variable charge and spin multiplicity, and for large-scale molecular dynamics where throughput rather than the last increment of accuracy is the binding constraint. Accuracy outside this domain should be validated before use.
• PyTorch Exportable backend only (dp --pt-expt); export is .pt2 (AOTInductor).
• The descriptor is one-hop local by construction. Interactions beyond rcut are not represented.
• The default charge/spin condition is [0, 1]. In ASE, set atoms.info["charge_spin"] to the physical [charge, multiplicity].
• Model compression requires CUDA, float32, and a configuration inside the compiled sets (channels in {8, 16, 32, 64, 128}, lmax in {2, 3, 4}, radial_modes in {0, 2, 4, 8}). All released sizes satisfy these constraints.
• The device-resident inference path requires a Kokkos-enabled LAMMPS build on the GPU backend and the compressed archive.

Citation

If you use these models, please cite the DPA4C paper and DeePMD-kit, and acknowledge the OMol25 dataset.

@article{li2026dpa4c,
  title   = {Universal Machine-learning Molecular Dynamics at the Speed
             of Empirical Potentials},
  author  = {Li, Tiancheng and Xue, Jianming and Zhang, Linfeng and
             Zhang, Duo and Wang, Han},
  journal = {arXiv preprint arXiv:2608.19041},
  year    = {2026},
  doi     = {10.48550/arXiv.2608.19041},
  url     = {https://arxiv.org/abs/2608.19041}
}

@article{Wang_ComputPhysCommun_2018_v228_p178,
  author    = {Wang, Han and Zhang, Linfeng and Han, Jiequn and E, Weinan},
  title     = {{DeePMD-kit: A deep learning package for many-body potential
               energy representation and molecular dynamics}},
  journal   = {Comput. Phys. Comm.},
  volume    = {228},
  pages     = {178--184},
  year      = {2018},
  doi       = {10.1016/j.cpc.2018.03.016}
}

@article{Zeng_JChemPhys_2023_v159_p054801,
  author    = {Jinzhe Zeng and Duo Zhang and Denghui Lu and Pinghui Mo and Zeyu
               Li and Yixiao Chen and Mari{\'a}n Rynik and Li'ang Huang and Ziyao
               Li and Shaochen Shi and Yingze Wang and Haotian Ye and Ping Tuo
               and Jiabin Yang and Ye Ding and Yifan Li and Davide Tisi and Qiyu
               Zeng and Han Bao and Yu Xia and Jiameng Huang and Koki Muraoka and
               Yibo Wang and Junhan Chang and Fengbo Yuan and Sigbj{\o}rn
               L{\o}land Bore and Chun Cai and Yinnian Lin and Bo Wang and Jiayan
               Xu and Jia-Xin Zhu and Chenxing Luo and Yuzhi Zhang and Rhys E A
               Goodall and Wenshuo Liang and Anurag Kumar Singh and Sikai Yao and
               Jingchao Zhang and Renata Wentzcovitch and Jiequn Han and Jie Liu
               and Weile Jia and Darrin M York and Weinan E and Roberto Car and
               Linfeng Zhang and Han Wang},
  title     = {{DeePMD-kit v2: A software package for deep potential models}},
  journal   = {J. Chem. Phys.},
  volume    = {159},
  issue     = {5},
  pages     = {054801},
  year      = {2023},
  doi       = {10.1063/5.0155600}
}

@article{Zeng_JChemTheoryComput_2025_v21_p4375,
  author    = {Jinzhe Zeng and Duo Zhang and Anyang Peng and Xiangyu Zhang and
               Sensen He and Yan Wang and Xinzijian Liu and Hangrui Bi and Yifan
               Li and Chun Cai and Chengqian Zhang and Yiming Du and Jia-Xin Zhu
               and Pinghui Mo and Zhengtao Huang and Qiyu Zeng and Shaochen Shi
               and Xuejian Qin and Zhaoxi Yu and Chenxing Luo and Ye Ding and
               Yun-Pei Liu and Ruosong Shi and Zhenyu Wang and Sigbj{\o}rn
               L{\o}land Bore and Junhan Chang and Zhe Deng and Zhaohan Ding and
               Siyuan Han and Wanrun Jiang and Guolin Ke and Zhaoqing Liu and
               Denghui Lu and Koki Muraoka and Hananeh Oliaei and Anurag Kumar
               Singh and Haohui Que and Weihong Xu and Zhangmancang Xu and
               Yong-Bin Zhuang and Jiayu Dai and Timothy J. Giese and Weile Jia
               and Ben Xu and Darrin M. York and Linfeng Zhang and Han Wang},
  title     = {{DeePMD-kit v3: A Multiple-Backend Framework for Machine Learning
               Potentials}},
  journal   = {J. Chem. Theory Comput.},
  volume    = {21},
  number    = {9},
  pages     = {4375--4385},
  year      = {2025},
  doi       = {10.1021/acs.jctc.5c00340}
}

@misc{levine2025omol25,
  title         = {The Open Molecules 2025 ({OMol25}) Dataset, Evaluations,
                   and Models},
  author        = {Levine, Daniel S. and Shuaibi, Muhammed and
                   Spotte-Smith, Evan Walter Clark and Taylor, Michael G. and
                   Hasyim, Muhammad R. and Michel, Kyle and Batatia, Ilyes and
                   Cs{\'a}nyi, G{\'a}bor and Dzamba, Misko and Eastman, Peter
                   and Frey, Nathan C. and Fu, Xiang and Gharakhanyan, Vahe
                   and Krishnapriyan, Aditi S. and Rackers, Joshua A. and
                   Raja, Sanjeev and Rizvi, Ammar and Rosen, Andrew S. and
                   Ulissi, Zachary and Vargas, Santiago and
                   Zitnick, C. Lawrence and Blau, Samuel M. and
                   Wood, Brandon M.},
  year          = {2025},
  eprint        = {2505.08762},
  archivePrefix = {arXiv},
  primaryClass  = {physics.chem-ph},
  doi           = {10.48550/arXiv.2505.08762},
  url           = {https://arxiv.org/abs/2505.08762}
}