Paper: https://arxiv.org/abs/2509.21624
Official repo: https://github.com/BurgerAndreas/hip
MACE implementation (work in progress): https://github.com/BurgerAndreas/hip-mace
HIPs are machine learning interatomic potentials (MLIPs) that directly predict the Hessian, in addition to the usual energy and forces. This repo primarily trains HIP-EquiformerV2 on the HORM Hessian dataset, which consists of off-equilibrium geometries of small, neutral organic molecules, contained H, C, N, O, based on Transition1x, at the $\omega$B97X/6-31G(d) level of theory.
Compared to autograd Hessians, HIP is:
- 10-70x faster for a single molecule of 5-30 atoms
- 70x faster for a typical T1x batch in batched prediction
- 3x memory reduction
- Better accuracy (Hessian, Hessian eigenvalues and eigenvectors)
- Better downstream accuracy (relaxation, transition state search, frequency analysis)
Speed and memory comparison
This should only take 5-10 minutes depending on your internet connection.
First install the uv package manager (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"git clone git@github.com:BurgerAndreas/hip.git
cd hip
# --extra cuda126
uv sync --python 3.12 --extra cuda121Download the latest checkpoints from HuggingFace:
mkdir -p ckpt
wget https://huggingface.co/andreasburger/hip/resolve/main/ckpt/hip_v3-1.ckpt -O ckpt/hip_v3-1.ckpt
wget https://huggingface.co/andreasburger/hip/resolve/main/ckpt/hip_v3.ckpt -O ckpt/hip_v3.ckpt
wget https://huggingface.co/andreasburger/hip/resolve/main/ckpt/hip_v3.yaml -O ckpt/hip_v3.yaml
wget https://huggingface.co/andreasburger/hip/resolve/main/ckpt/hip_v3_cf.ckpt -O ckpt/hip_v3_cf.ckpt
wget https://huggingface.co/andreasburger/hip/resolve/main/ckpt/hip_v3_cf.yaml -O ckpt/hip_v3_cf.yamlAvailable checkpoints:
hip_v3-1.ckpt(recommended): same weights aship_v3.ckpt, with the Hessian-graph settings fixed (see below).hip_v2-1.ckpt: same weights aship_v2.ckpt, with the Hessian-graph settings fixed.hip_v3.ckpt: HIP checkpoint with direct force prediction, as used in the paper.hip_v3_cf.ckpt: latest HIP checkpoint trained with conservative forces (model.direct_forces=False).hip_v3.yamlandhip_v3_cf.yaml: saved model, optimizer, and training configs for the matching checkpoints.
The backbone of hip_v2 and hip_v3 was trained with a 5 Å radius graph, and the Hessian head only saw
atom pairs up to ~5-12 Å (the largest pair distance in the training set is 12.21 Å). Evaluating the
Hessian head on a fully connected graph, the old default, makes Hessians of larger molecules much worse
(e.g. ~40x on PubChem molecules with 30-100 atoms). Use:
| checkpoint | backbone cutoff | max_neighbors |
Hessian graph |
|---|---|---|---|
hip_v3-1.ckpt (recommended) |
5 Å (as trained) | 1000 (no cap) | 6 Å radius graph (5-7 Å all work) |
hip_v2-1.ckpt |
5 Å (as trained) | 1000 (no cap) | 5 Å radius graph |
The -1 checkpoints store these settings (fully_connected_hessian: false, hessian_graph_cutoff,
max_neighbors: 1000). Checkpoints without fully_connected_hessian in their config, like
hip_v2.ckpt and hip_v3.ckpt, now fall back to a Hessian graph with the backbone cutoff (5 Å) and
no neighbour cap, and log a warning. cutoff_hessian only sets the range of the Hessian-head distance
basis and must stay at its trained value (100). Details and benchmarks:
results_cutoff_ablation.
For training new models, the ideal settings going forward are a 5 Å backbone and a 5 Å Hessian graph
with no neighbour cap and a smooth envelope on all edges (configs/train_envelope.yaml), which gave the
best size extrapolation in our ablations.
Run a few forward passes (should take 30s)
uv run example.pyOur models are trained on the Hessian dataset for Optimizing Reactive MLIP (HORM).
The HORM dataset is hosted on Kaggle.
Kaggle automatically downloads to the ~/.cache folder.
If you want to use another location for the files, I recommend to set up a symbolic link to a another folder:
PROJECT = <folder where you want to store the dataset>
mkdir -p ${PROJECT}/.cache
ln -s ${PROJECT}/.cache ${HOME}/.cacheNow download the HORM dataset (25GB):
uv run scripts/download_horm_data_kaggle.pyTrain HIP (around two to three days on a H100 GPU)
uv run scripts/train.py
# conservative forces
uv run scripts/train.py model.direct_forces=False
# reduce the batch size if you are running on a L40s or A100 with 40GB GPU RAM
# uv run scripts/train.py +extra=bz64For the transition state search we followed the HORM paper and used ReactBench
- https://github.com/deepprinciple/ReactBench
- https://github.com/deepprinciple/pysisyphus
- https://github.com/deepprinciple/pyGSM
Unfortunetly, the ReactBench code is a bit of a mess.
If I were to do this project again, I would use geodesic interpolation + Sella TS search + Sella IRC instead of ReactBench + pysisyphus + pyGSM as done in this paper:
https://www.nature.com/articles/s41467-024-52481-5
For that you would need to install:
https://github.com/virtualzx-nad/geodesic-interpolate
https://github.com/zadorlab/sella
and follow their workflow from here:
https://github.com/Quantum-Accelerators/quacc/blob/main/src/quacc/recipes/newtonnet/ts.py
If I can help you run the code or setup your own project, please email me at: <firstname>.<lastname>(at)mail.utoronto.ca
If you found this code useful, please consider citing:
@misc{burger2025hiphessian,
title={Shoot from the HIP: Hessian Interatomic Potentials without derivatives},
author={Andreas Burger and Luca Thiede and Nikolaj Rønne and Varinia Bernales and Nandita Vijaykumar and Tejs Vegge and Arghya Bhowmik and Alan Aspuru-Guzik},
year={2025},
eprint={2509.21624},
archivePrefix={arXiv},
primaryClass={cs.LG},
url={https://arxiv.org/abs/2509.21624},
}The dataset and parts of the training code are based on the HORM paper, dataset, and code We thank the authors of from DeepPrinciple for making their code and data openly available.