Accelerating AI-Powered Chemistry and Materials Science Simulations with NVIDIA ALCHEMI Toolkit-Ops

Machine learning interatomic potentials (MLIPs) are transforming the landscape of computational chemistry and materials science. MLIPs enable atomistic simulations that mix the fidelity of computationally expensive quantum chemistry with the scaling power of AI. 

Yet, developers working at this intersection face a persistent challenge: an absence of strong, Pythonic toolbox for GPU-accelerated atomistic simulation. To be used cases similar to running numerous simultaneous, GPU-accelerated simulations, robust and well-supported tools are either missing in the present software ecosystem or are fragmented across several open source software tools.

Over the past few years, available software for running atomistic simulations with MLIPs has been CPU-centric. Core operations similar to neighbor identification, dispersion corrections, long-range interactions, and their associated gradient calculation have traditionally supported only CPU computation, which regularly struggles to deliver the speed that contemporary research demands. High-throughput simulations of small- to medium-sized atomic systems quickly turn into bottlenecked by inefficient GPU usage in hybrid workflows where the model is GPU-accelerated in PyTorch however the simulation tooling is serial and CPU-based.

While developers have attempted to implement these operations directly in PyTorch through the years, the general-purpose design of PyTorch leaves performance on the table for the specialized spatial and force calculation operations required in atomistic simulation. This fundamental mismatch between PyTorch capabilities and the demands of atomistic modeling raises a crucial query: What’s needed to bridge this gap?

NVIDIA ALCHEMI (AI Lab for Chemistry and Materials Innovation), announced at Supercomputing 2024, provides chemistry and materials science developers and researchers with domain-specialized toolkits and NVIDIA NIM microservices optimized on NVIDIA accelerated computing platforms. It’s a group of high-performance, batched and GPU-accelerated tools specifically for enabling atomistic simulations in chemistry and materials science research on the machine learning framework level.

NVIDIA ALCHEMI delivers capabilities across three integrated layers:

• ALCHEMI Toolkit-Ops: A repository of GPU-accelerated, batched common operations for AI-enabled atomistic simulation tasks, similar to neighbor list construction, DFT-D3 dispersion corrections, and long-range electrostatics.
• ALCHEMI Toolkit: A group of GPU-accelerated simulation constructing blocks, including geometry optimizers, integrators, and data structures to enable large-scale, batched simulations leveraging AI.
• ALCHEMI NIM microservices: A scalable layer of cloud‑ready, domain‑specific microservices for chemistry and materials science, enabling deployment and orchestration on NVIDIA‑accelerated platforms.

This post introduces NVIDIA ALCHEMI Toolkit-Ops, the accelerated batched common operations layer of ALCHEMI. ALCHEMI Toolkit-Ops uses NVIDIA Warp to speed up and batch common operations in AI-driven atomistic modeling. These operations are exposed through a modular PyTorch accessible API (with a JAX API targeted for a future release) that permits rapid iteration and integration with existing and future atomistic simulation packages.

Figure 1 shows the accelerated batched common operations for atomistic simulations included on this initial release of ALCHEMI Toolkit-Ops. This beta release includes two versions of neighbor lists (naive and cell), DFT-D3 dispersion correction, and long-range coulombic (Ewald and Particle Mesh Ewald) functions. 

Figure 2 demonstrates the performance of accelerated kernels in ALCHEMI Toolkit-Ops versus popular kernel-accelerated models like MACE (cuEquivariance) and TensorNet (Warp) to attain fully parallelized performance and scalability. The blue MLIP baseline allows comparison with advanced features like neighbor lists and dispersion corrections (DFT-D3). Test systems consisted of ammonia clusters of accelerating size packed into various cells using Packmol. Timing results were averaged over 20 runs on an NVIDIA H100 80 GB GPU. The DFT-D3 calculation doesn’t include 6Å as a result of the long-range nature of D3.

ALCHEMI Toolkit-Ops is designed to integrate seamlessly with the broader PyTorch-based atomistic simulation ecosystem. We’re excited to announce in-progress integrations with leading open source tools within the chemistry and materials science community: TorchSim, MatGL, and AIMNet Central.

TorchSim

# Install via pip wheel
pip install nvalchemi-toolkit-ops

# Make certain it's importable
python -c "import nvalchemiops; print(nvalchemiops.__version__)"

import torch
from nvalchemiops.neighborlist import neighbor_list


# Water molecule
water_positions = torch.tensor([
   [0.0, 0.0, 0.0],      # O
   [0.96, 0.0, 0.0],     # H
   [-0.24, 0.93, 0.0],   # H
], device="cuda", dtype=torch.float32)
# Ammonia molecule (NH3)
ammonia_positions = torch.tensor([
   [0.0, 0.0, 0.0],      # N
   [1.01, 0.0, 0.0],     # H
   [-0.34, 0.95, 0.0],   # H
   [-0.34, -0.48, 0.82], # H
], device="cuda", dtype=torch.float32)
# Concatenate positions for batch processing
positions = torch.cat([water_positions, ammonia_positions], dim=0)
# Create batch indices (0 for water, 1 for ammonia)
batch_idx = torch.cat([
   torch.zeros(3, dtype=torch.int32, device="cuda"),   # Water
   torch.ones(4, dtype=torch.int32, device="cuda"),    # Ammonia
])
# Define cells for every molecule (large enough to contain them without PBC)
cells = torch.stack([
   torch.eye(3, device="cuda") * 10.0,  # Water cell
   torch.eye(3, device="cuda") * 10.0,  # Ammonia cell
])
# non-periodic molecule case
pbc = torch.tensor([
   [False, False, False],  # Water
   [False, False, False],  # Ammonia
], device="cuda")
# Cutoff distance in Angstroms
cutoff = 4.0
# Compute neighbor list; here we explicitly request a batched cell list algorithm
neighbor_matrix, num_neighbors, shift_matrix = neighbor_list(
   positions, cutoff, cell=cells, pbc=pbc, batch_idx=batch_idx, method="batch_cell_list"
)
print(f"Neighbor matrix: {neighbor_matrix.cpu()}")  # [7, num_neighbors.max()]
print(f"Neighbors per atom: {num_neighbors.cpu()}")  # [7,]
print(f"Periodic shifts: {shift_matrix.cpu()}")

from nvalchemiops.interactions.dispersion import dftd3

batch_ptr = torch.tensor([0, 3, 7], dtype=torch.int32, device="cuda")
atomic_numbers = torch.tensor(
    [6, 1, 1, 7, 1, 1, 1], dtype=torch.int32, device="cuda"
)
# For this snippet, assume d3_params is loaded as:
# d3_params = D3Parameters(rcov=..., r4r2=..., c6ab=..., cn_ref=...)
# Users can consult with the documentation to source DFT-D3 parameters
# and understand the expected data structure
d3_params = ...
# call the DFT-D3 functional interface
energy, forces, coordination_numbers = dftd3(
    positions=positions,
    numbers=atomic_numbers,
	 a1=0.3981, a2=4.4211, s8=0.7875,  # PBE parameters
    neighbor_matrix=neighbor_matrix,
    neighbor_matrix_shifts=shift_matrix,
    batch_idx=batch_idx,
    d3_params=d3_params
)
print(f"Energies: {energy.cpu()}")  # [2,]
print(f"Forces: {forces.cpu()}")  # [7, 3]

from nvalchemiops.interactions.electrostatics import particle_mesh_ewald

# charges for every atom are randomly generated here
atomic_charges = torch.randn(
    positions.size(0),  dtype=torch.float32, device="cuda"
)
# compute energy and forces with particle mesh ewald
energy, forces = particle_mesh_ewald(
    positions,
    atomic_charges,
    cells,
    alpha=0.3,  # adjust Ewald splitting parameter
    batch_idx=batch_idx,
    neighbor_matrix=neighbor_matrix,
    neighbor_matrix_shifts=shift_matrix,
    compute_forces=True
)
print(f"Energy: {energy.cpu()}")  # [2]
print(f"Forces: {forces.cpu()}")  # [7, 3]