GPU4PySCF

This document provides performance benchmarks for Periodic Boundary Condition (PBC) Density Functional Theory (DFT) calculations using gpu4pyscf. The benchmarks cover different functional types and integration methods across various crystal systems.

Hardware Environment:

• GPU: 1 NVIDIA A100 card
• Host Memory: 200 GB

When comparing GPU4PySCF performance benchmarks against other quantum chemistry packages (like Q-Chem or Psi4), ensure that all physical and numerical settings are identical. Differences in the following parameters will make performance comparisons invalid:

• Integral thresholds: The precision required for calculating integrals.
• Convergence tolerance: The threshold for SCF or other iterative convergence.
• Basis set type: Whether using Cartesian or spherical basis sets.
• Grids: The density and type of integration grids used.

If you need to build the package from source, follow these steps:

1. Clone the repository:

git clone https://github.com/pyscf/gpu4pyscf.git
cd gpu4pyscf

2. Build using CMake:

cmake -S gpu4pyscf/lib -B build/temp.gpu4pyscf
cmake --build build/temp.gpu4pyscf -j 4

3. Update your PYTHONPATH:

CURRENT_PATH=`pwd`
export PYTHONPATH="${PYTHONPATH}:${CURRENT_PATH}"

4. Install acceleration dependencies (ensure versions match your CUDA environment):

pip3 install cutensor-cu12 cupy-cuda12x

Troubleshooting: If you see the following warning at the start of a job, it indicates a problem with your cupy or cutensor installation (likely a version mismatch or duplicate installations): <repo_path>/gpu4pyscf/lib/cutensor.py:<line_number>: UserWarning: using cupy as the tensor contraction engine.

When integrating GPU4PySCF into a PySCF codebase, be mindful of where tensors reside:

• Input Arrays: CuPy arrays are preferred. NumPy arrays are accepted but will be handled by the library.
• Calculation Results (Attributes):
  • Energies (energy, gradients, Hessians) $\rightarrow$ NumPy arrays.
  • Wavefunctions (coefficients, energies, occupancies, amplitudes) $\rightarrow$ CuPy arrays.

Use cupy.asarray(x) to move to GPU and cupy.asnumpy(x) to move to CPU.

import cupy as cp

# Convert to a CuPy array for GPU processing
x_gpu = cp.asarray(x_cpu)

# Convert back to NumPy for CPU processing
x_cpu = cp.asnumpy(x_gpu)

GPU4PySCF performance can be benchmarked against Psi4 v1.8. The benchmarks evaluate Direct SCF Energy across various functionals and basis sets.

In the benchmark results:

• Difference values represent the numerical difference in energy between GPU4PySCF and Psi4.
• Speedup values represent the performance factor of GPU4PySCF relative to Psi4.
• A value of -1 (or -1.00e+00) indicates that the computation was too expensive to complete in Psi4 for that specific configuration.

Key benchmarked configurations include:

• B3LYP/ with STO-3G or 6-31G basis sets*
• Various functionals (HF, PBE, M06, B3LYP) with the def2-tzvpp basis set

To visualize electronic properties or orbitals, you can export data to standard formats:

• Cube format: Use pyscf.tools.cubegen to export densities or potentials to .cube files, compatible with VMD or Jmol.
• Molden format: Use pyscf.tools.molden to export orbital coefficients to .molden files.

from pyscf.tools import cubegen, molden

# Export electron density to cube
cubegen.density(mol, 'density.cube', mf.make_rdm1())

# Export orbitals to molden
molden.from_scf(mf, 'scf_results.molden')

You can install GPU4PySCF directly from PyPI or by cloning the repository and building it similarly to PySCF.

pip install gpu4pyscf

Geometry optimization for molecules and crystals can be performed using the geomeTRIC or ASE packages via PySCF's wrapper interface.

For methods implemented in both PySCF and GPU4PySCF, use the .optimizer() method of the Gradients class.

# Optimize molecular geometry using GPU4PySCF
mol.RKS(xc='wb97mv').to_gpu().Gradients().optimizer().run()

# Optimize crystal lattice and atomic positions
cell.KRKS(xc='pbe', kpts=cell.make_kpts([2,2,2])).to_gpu().Gradients().optimizer().run()

cuEST (CUDA Electronic Structure Theory) accelerates ERI computations, specifically improving density-fitting J/K construction.

Performance Gains:

• Ampere: ~1.5x
• Hopper: ~3x
• Blackwell: ~5x
• RTX PRO 6000: ~15x

Limitations:

• Does not support Volta GPUs.
• Does not support Python 3.10 or earlier.
• DFT XC integrals and density evaluation remain inefficient.

Usage: Use the apply_cuest_wrapper from gpu4pyscf.lib.cuest_wrapper.

from gpu4pyscf.lib.cuest_wrapper import apply_cuest_wrapper

mf = mol.to_gpu().RKS(xc='pbe0').density_fit()
mf = apply_cuest_wrapper(mf)

# To turn off the cuEST DFT XC part specifically:
mf._numint.turn_on_cuest_xc = False