update: model weights, evaluation script

.gitattributes

@@ -1 +1,3 @@
 *.lmdb filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -34,6 +34,18 @@ We propose a framework for accelerating DFT calculations.
 
 We train E(3)-equivariant neural networks to predict the expansion coefficients of the electron density in an auxiliary basis, and use the prediction to construct an initial guess for the SCF process. This approach exhibits superior transferability in various aspects.
 
+# Changelog
+
+## 2026.3.7
+
+* The full evaluation code is released.
+* The train/valid/test split of the main dataset is released.
+* The model weights of the NequIP model are released.
+
+## 2025.12.1
+
+* First release.
+
 # Contents
 
 The repo currently contains the following contents:
@@ -41,12 +53,8 @@ The repo currently contains the following contents:
 * The full SCFbench dataset.
 * The data pipeline for the SCFbench dataset.
 * The PyTorch `nn.Module` of the species-wise linear layer for the prediction of the electron density coefficients.
-* The NequIP model architecture with the species-wise linear layer.
+* The NequIP model code and weights with the species-wise linear layer.
 * Example code for computing the density coefficients from a density matrix.
-
-We will also release the following items soon:
-
-* The training code for models.
 * The full evaluation code.
 
 
@@ -92,6 +100,11 @@ dataset[0].keys()
 dataset.dataset[0].keys()
 ```
 
+# Evaluation
+
+To evaluate 
+
+
 # Citing SCFbench
 If you use SCFbench in your research, please cite:
 ```latex

dataset.py

@@ -30,6 +30,25 @@ def compute_edge_index(coords, r_max, remove_self_loops=True):
     return edge_index
 
 
+def collate_key_nonindex(samples, key):
+    items = [s[key] for s in samples]
+    return torch.cat(items, dim=0)
+
+
+def collate_key_index(samples, key, atom_index_cumsum, cat_dim):
+    return torch.cat([
+        s[key] + atom_index_cumsum[i]
+        for i, s in enumerate(samples)
+    ], dim=cat_dim)
+
+
+def get_batch_vector(samples, node_level_key='z'):
+    natoms = [len(s[node_level_key]) for s in samples]
+    return torch.LongTensor([
+        isample for isample, n in enumerate(natoms) for _ in range(n)
+    ])
+
+
 class ShardedLMDBDataset(Dataset):
     def __init__(self, data_root: str):
         super().__init__()
@@ -243,3 +262,48 @@ class SCFBenchDataset(Dataset):
             )
 
         return ret
+
+    def collater(self, samples):
+        batch = {}
+        batch.update({
+            key: collate_key_nonindex(samples, key)
+            for key in ['z', 'pos', 'net_charge', 'spin']
+        })
+
+        natoms = [len(s['z']) for s in samples]
+        atom_index_cumsum = [0] + list(np.cumsum(natoms))
+
+        if any(p.startswith('auxdensity') for p in self.parts_to_load):
+            batch.update({
+                'auxdensity': {
+                    key: collate_key_nonindex([s['auxdensity'] for s in samples], key)
+                    for key in self.type_names
+                },
+                'species_indices': {
+                    key: collate_key_index([s['species_indices'] for s in samples], key, atom_index_cumsum, 0)
+                    for key in self.type_names
+                },
+            })
+
+        if 'dm' in self.parts_to_load:
+            batch.update({
+                'dm_diag_blocks': collate_key_nonindex(samples, 'dm_diag_blocks'),
+                'dm_diag_masks': collate_key_nonindex(samples, 'dm_diag_masks'),
+                'dm_tril_blocks': collate_key_nonindex(samples, 'dm_tril_blocks'),
+                'dm_tril_masks': collate_key_nonindex(samples, 'dm_tril_masks'),
+                'dm_tril_edge_index': collate_key_index(samples, 'dm_tril_edge_index', atom_index_cumsum, 1),
+            })
+
+        if 'fock' in self.parts_to_load:
+            batch.update({
+                'fock_diag_blocks': collate_key_nonindex(samples, 'fock_diag_blocks'),
+                'fock_diag_masks': collate_key_nonindex(samples, 'fock_diag_masks'),
+                'fock_tril_blocks': collate_key_nonindex(samples, 'fock_tril_blocks'),
+                'fock_tril_masks': collate_key_nonindex(samples, 'fock_tril_masks'),
+                'fock_tril_edge_index': collate_key_index(samples, 'fock_tril_edge_index', atom_index_cumsum, 1),
+            })
+
+        batch['batch'] = get_batch_vector(samples, node_level_key='z')
+        batch['edge_index'] = collate_key_index(samples, 'edge_index', atom_index_cumsum, 1)
+        batch['bsz'] = len(samples)
+        return batch

evaluate_scf_gpu.py

@@ -0,0 +1,461 @@
+import os
+import json
+import time
+import argparse
+from functools import partial
+
+import tqdm
+import numpy as np
+import scipy
+import pandas as pd
+
+import torch
+from torch.utils.data import DataLoader, Subset
+
+import cupy as cp
+import pyscf
+import pyscf.df
+
+from gto import GTOBasis, element_to_atomic_number, GTOProductBasisHelper, build_irreps_from_mol, pyscf_to_standard_perm_D
+from dataset import SCFBenchDataset
+from nequip_model import nequip_simple_builder
+
+
+def move_data_to_device(data, device):
+    def move(x):
+        if isinstance(x, torch.Tensor):
+            return x.to(device)
+        elif isinstance(x, dict):
+            return {k: move(v) for k, v in x.items()}
+        else:
+            return x
+    return move(data)
+
+
+def run_scf_and_count_steps(mol, xc, dm0=None, verbose=False, with_df=False, with_df_basis='def2-svp-jkfit'):
+    t_start = time.time()
+
+    mf = mol.RKS(xc=xc)
+    if with_df:
+        mf = mf.density_fit(auxbasis=with_df_basis)
+    mf = mf.to_gpu()
+    if verbose:
+        mf.verbose = 4
+    else:
+        mf.verbose = 0
+
+    mf.scf(dm0=dm0)
+    steps = mf.cycles if mf.converged else -1
+    e_tot = mf.e_tot
+
+    return e_tot, steps, time.time() - t_start
+
+
+def transfer_fock(mol, transfer_mol, fock):
+    S_cross = pyscf.gto.mole.intor_cross('int1e_ovlp', mol, transfer_mol)
+    S1 = mol.intor('int1e_ovlp')
+    C = scipy.linalg.solve(S1, S_cross)
+    transfer_fock = C.T.dot(fock).dot(C)
+    return transfer_fock
+
+
+def dm_from_fock(mol, overlap, fock):
+    # from QHNet
+    overlap = torch.tensor(overlap)
+    fock = torch.tensor(fock)
+    eigvals, eigvecs = torch.linalg.eigh(overlap)
+    eps = 1e-8 * torch.ones_like(eigvals)
+    eigvals = torch.where(eigvals > 1e-8, eigvals, eps)
+    frac_overlap = eigvecs / torch.sqrt(eigvals).unsqueeze(-2)
+
+    Fs = torch.mm(torch.mm(frac_overlap.transpose(-1, -2), fock), frac_overlap)
+    orbital_energies, orbital_coefficients = torch.linalg.eigh(Fs)
+    orbital_coefficients = torch.mm(frac_overlap, orbital_coefficients)
+    num_orb = mol.nelectron // 2
+    orbital_coefficients = orbital_coefficients.squeeze()
+    dm0 = orbital_coefficients[:, :num_orb].matmul(orbital_coefficients[:, :num_orb].T) * 2
+    dm0 = dm0.cpu().numpy()
+    return dm0
+
+
+def dm_from_auxdensity(mol, auxmol, xc, aux_vec, normalize_nelec, transfer_mol=None):
+    import numpy
+    import cupy
+    from pyscf import lib
+    import gpu4pyscf.scf.jk
+    from gpu4pyscf.df.int3c2e_bdiv import Int3c2eOpt
+    from gpu4pyscf.lib.cupy_helper import contract
+    from gpu4pyscf.dft.numint import NumInt, add_sparse, _tau_dot, _scale_ao, _GDFTOpt
+    from gpu4pyscf.dft import Grids
+    from gpu4pyscf.lib.cupy_helper import transpose_sum
+
+    def nr_rks(xctype, mol, xc_code, auxmol, aux_vec):
+        # xctype = ni._xc_type(xc_code)
+        if xctype == 'LDA':
+            ao_deriv = 0
+        else:
+            ao_deriv = 1
+        comp = (ao_deriv+1)*(ao_deriv+2)*(ao_deriv+3)//6
+
+        grids = Grids(mol).build()
+        ngrids = grids.weights.size
+
+        rho = cupy.zeros((comp, ngrids))
+        aux_ni = NumInt().build(auxmol, grids)
+        naux = aux_ni.gdftopt._sorted_mol.nao
+        _sorted_aux_vec = aux_ni.gdftopt.sort_orbitals(aux_vec, axis=[0])
+
+        p0 = p1 = 0
+        for aux_ao_on_grids, idx, weight, _ in aux_ni.block_loop(aux_ni.gdftopt._sorted_mol, grids, naux, ao_deriv):
+            p0, p1 = p1, p1 + weight.size
+            rho[:,p0:p1] = (contract('xig,i->xg', aux_ao_on_grids, _sorted_aux_vec[idx]))
+
+        del aux_ao_on_grids, _sorted_aux_vec
+
+        grids = Grids(mol).build()
+        ni = NumInt().build(mol, grids)
+        if xctype == 'MGGA':
+            rho = cupy.vstack([rho, (rho[1:4]**2).sum(axis=0)/rho[0]/8])
+        weights = cupy.asarray(grids.weights)
+        nelec = rho[0].dot(weights)
+        exc, vxc = ni.eval_xc_eff(xc_code, rho, deriv=1, xctype=xctype)[:2]
+        vxc = cupy.asarray(vxc, order='C')
+        exc = cupy.asarray(exc, order='C')
+        excsum = float(cupy.dot(rho[0]*weights, exc[:,0]))
+        wv = vxc
+        wv *= weights
+        if xctype == 'GGA':
+            wv[0] *= .5
+        if xctype == 'MGGA':
+            wv[[0,4]] *= .5
+
+        opt = ni.gdftopt
+        _sorted_mol = opt._sorted_mol
+        nao = _sorted_mol.nao
+        buf = None
+        vtmp_buf = cupy.empty(nao*nao)
+        vmat = cupy.zeros((nao, nao))
+        p0 = p1 = 0
+        for ao_mask, idx, weight, _ in ni.block_loop(
+                _sorted_mol, grids, nao, ao_deriv, max_memory=None):
+            p0, p1 = p1, p1 + weight.size
+            nao_sub = len(idx)
+            vtmp = cupy.ndarray((nao_sub, nao_sub), memptr=vtmp_buf.data)
+            if xctype == 'LDA':
+                aow = _scale_ao(ao_mask, wv[0,p0:p1], out=buf)
+                add_sparse(vmat, ao_mask.dot(aow.T, out=vtmp), idx)
+            elif xctype == 'GGA':
+                aow = _scale_ao(ao_mask, wv[:,p0:p1], out=buf)
+                add_sparse(vmat, ao_mask[0].dot(aow.T, out=vtmp), idx)
+            elif xctype == 'MGGA':
+                vtmp = _tau_dot(ao_mask, ao_mask, wv[4,p0:p1], buf=buf, out=vtmp)
+                aow = _scale_ao(ao_mask, wv[:4,p0:p1], out=buf)
+                vtmp = contract('ig,jg->ij', ao_mask[0], aow, beta=1., out=vtmp)
+                add_sparse(vmat, vtmp, idx)
+        vmat = opt.unsort_orbitals(vmat, axis=[0,1])
+        if xctype != 'LDA':
+            transpose_sum(vmat)
+        return nelec, excsum, vmat
+
+    def get_j(mol, auxmol, aux_vec):
+        int3c2e_opt = Int3c2eOpt(mol, auxmol).build()
+        aux_vec_sorted = cupy.asarray(int3c2e_opt.aux_coeff).dot(cupy.asarray(aux_vec))
+        p1 = 0
+        J_compressed = 0
+        for eri3c in int3c2e_opt.int3c2e_bdiv_generator(batch_size=1200):
+            p0, p1 = p1, p1 + eri3c.shape[1]
+            J_compressed += eri3c.dot(aux_vec_sorted[p0:p1])
+        nao = int3c2e_opt.sorted_mol.nao
+        J = cupy.zeros((nao, nao))
+        ao_pair_mapping = int3c2e_opt.create_ao_pair_mapping()
+        rows, cols = divmod(cupy.asarray(ao_pair_mapping), nao)
+        J[rows, cols] = J[cols, rows] = J_compressed
+        c = cupy.asarray(int3c2e_opt.coeff)
+        return c.T.dot(J).dot(c)
+
+    def get_jk(mol, dm, auxmol, aux_vec):
+        vj = get_j(mol, auxmol, aux_vec)
+        _, vk = gpu4pyscf.scf.jk.get_jk(mol, dm, 1, with_j=False)
+        return vj, vk
+
+    def get_veff(ks, auxmol, aux_vec, dm, mol=None, hermi=1):
+        time_stats = {}
+        if mol is None: mol = ks.mol
+        ni = ks._numint
+        if hermi == 2:  # because rho = 0
+            n, exc, vxc = 0, 0, 0
+        else:
+            # no memory check
+            # max_memory = ks.max_memory - lib.current_memory()[0]
+            t_start = time.time()
+            n, exc, vxc = nr_rks(ni._xc_type(ks.xc), mol, ks.xc, auxmol, aux_vec)
+            time_stats['grid_eval_time'] = time.time() - t_start
+            if ks.do_nlc():
+                raise NotImplementedError
+        if not ni.libxc.is_hybrid_xc(ks.xc):
+            t_start = time.time()
+            vj = get_j(mol, auxmol, aux_vec)
+            time_stats['get_j_time'] = time.time() - t_start
+            vxc += vj
+        else:
+            omega, alpha, hyb = ni.rsh_and_hybrid_coeff(ks.xc, spin=mol.spin)
+            if omega == 0:
+                vj, vk = get_jk(mol, dm, auxmol, aux_vec)
+                vk *= hyb
+            else:
+                raise NotImplementedError
+            vxc += vj - vk * .5
+        return vxc, time_stats
+
+    def int1e1c_analytical(mol):
+        """
+        Calculate integral values
+        .. math:: \int_{-\infty}^{\infty} phi(r) dr
+        """
+        integral_val = []
+        for idx, aug_mom in enumerate(mol._bas[:, 1]):
+            if aug_mom == 0:
+                exponents = mol.bas_exp(idx)
+                norm = (2 * exponents / numpy.pi)**0.75
+                coeffs = mol.bas_ctr_coeff(idx)[:, 0]
+                integral_val.append(
+                    (coeffs * norm * (numpy.pi / exponents)**1.5).sum())
+            else:
+                integral_val += [0] * (2*aug_mom+1)
+        integral_val = numpy.array(integral_val)
+        return integral_val
+
+    extra_stats = {}
+
+    if normalize_nelec:
+        aux_1c1e = cp.array(int1e1c_analytical(auxmol))
+        aux_vec_nelec = aux_vec @ aux_1c1e
+        aux_vec *= mol.nelectron / aux_vec_nelec
+        extra_stats['aux_vec_nelec'] = aux_vec_nelec.get().item()
+
+    mf = mol.RKS(xc=xc).to_gpu()
+
+    dm_guess = 0
+    if mf._numint.libxc.is_hybrid_xc(mf.xc):
+        dm_guess = mf.get_init_guess()
+
+    fock, veff_time_stats = get_veff(mf, auxmol, aux_vec, dm_guess)
+    fock = fock + mf.get_hcore()
+    extra_stats.update(veff_time_stats)
+
+    if transfer_mol is not None:
+        fock = cupy.array(transfer_fock(mol, transfer_mol, fock.get()))
+        mol = transfer_mol
+
+    t_start = time.time()
+    s1e = mol.intor('int1e_ovlp')
+    mo_energy, mo_coeff = gpu4pyscf.lib.cupy_helper.eigh(cupy.array(fock), cupy.array(s1e))
+    extra_stats['eigh_time'] = time.time() - t_start
+    nocc = mol.nelectron // 2
+    mocc = mo_coeff[:,:nocc]
+    dm0 = mocc.dot(mocc.conj().T) * 2
+    dm0_numpy = dm0.get()
+    return dm0_numpy, extra_stats
+
+
+def build_mol_from_data(type_names, aobasis_name, data):
+    nuclei = [element_to_atomic_number[type_names[z]] for z in data['z'].cpu().numpy()]
+    coords = data['pos'].cpu().numpy()
+    mol = pyscf.M(atom=list(zip(nuclei, coords)), basis=aobasis_name)
+    return mol
+
+
+def pred_auxdensity_postprocess(mol, outputs, auxbasis_name, auxbasis, xc, use_denfit_ovlp, normalize_nelec, transfer_mol=None):
+    t0 = time.time()
+    preds = outputs['output:auxdensity']
+    if auxbasis_name.startswith('etb:'):
+        beta = float(auxbasis_name.split(':')[-1])
+        etb_basis = pyscf.df.aug_etb(mol, beta)
+        auxmol = pyscf.df.make_auxmol(mol, auxbasis=etb_basis)
+    else:
+        auxmol = pyscf.df.make_auxmol(mol, auxbasis=auxbasis_name)
+    atom_count_by_elements = {k: 0 for k in preds.keys()}
+    atom_vecs = []
+    for iatm in range(mol.natm):
+        symbol = mol.atom_pure_symbol(iatm)
+        atom_vecs.append(preds[symbol][atom_count_by_elements[symbol]])
+        atom_count_by_elements[symbol] += 1
+    aux_vec = torch.cat(atom_vecs)
+    mol_irreps = build_irreps_from_mol(auxmol)
+    aux_vec = pyscf_to_standard_perm_D(mol_irreps).T.to(aux_vec) @ aux_vec
+    aux_vec = aux_vec.cpu().numpy()
+    if use_denfit_ovlp:
+        aux_vec = np.linalg.solve(auxmol.intor('int1e_ovlp'), aux_vec)
+    t1 = time.time()
+    # dm = dm_from_auxdensity(mol, auxmol, xc, aux_vec, normalize_nelec, transfer_mol)
+    dm, time_stats = dm_from_auxdensity(mol, auxmol, xc, cp.array(aux_vec), normalize_nelec, transfer_mol)
+    time_stats['model_to_auxvec_time'] = t1 - t0
+    return dm, time_stats
+
+
+def pred_fock_postprocess(mol, outputs, ao_prod_basis, normalize_nelec, transfer_mol=None):
+    fock = ao_prod_basis.assemble_matrix_from_padded_blocks(mol.atom_charges(), outputs['output:fock_diag_blocks'].cpu().numpy(), outputs['output:fock_tril_blocks'].cpu().numpy())
+    fock = ao_prod_basis.transform_from_std_to_pyscf(mol.atom_charges(), fock)
+
+    if transfer_mol is None:
+        overlap = mol.intor('int1e_ovlp').astype(np.float32)
+        dm = dm_from_fock(mol, overlap, fock)
+    else:
+        overlap = transfer_mol.intor('int1e_ovlp')
+        transfer_fock = transfer_fock(mol, transfer_mol, fock)
+        dm = dm_from_fock(transfer_mol, overlap, transfer_fock)
+
+    if normalize_nelec:
+        dm *= mol.nelectron / (dm * overlap).sum()
+
+    return dm, {}
+
+
+def pred_dm_postprocess(mol, outputs, ao_prod_basis, normalize_nelec, transfer_mol=None):
+    dm = ao_prod_basis.assemble_matrix_from_padded_blocks(mol.atom_charges(), outputs['output:dm_diag_blocks'].cpu().numpy(), outputs['output:dm_tril_blocks'].cpu().numpy())
+    dm = ao_prod_basis.transform_from_std_to_pyscf(mol.atom_charges(), dm)
+
+    if normalize_nelec:
+        overlap = mol.intor('int1e_ovlp').astype(np.float32)
+        dm *= mol.nelectron / (dm * overlap).sum()
+    if transfer_mol is not None:
+        raise NotImplementedError
+    return dm, {}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--ckpt', type=str, help='Path to the checkpoint file')
+    parser.add_argument('--gt-mode', action='store_true', help='Use ground truth as initial guess.')
+    parser.add_argument('--data-root', default='./dataset/ood-test', type=str, help='Path to the data root directory')
+    parser.add_argument('--model-type', default='auxdensity', type=str, choices=['auxdensity', 'dm', 'fock'], help='Prediction type of the model')
+    parser.add_argument('--xc', default='PBE', type=str, help='XC functional')
+    parser.add_argument('--transfer-basis', default=None, type=str, help='Basis set to which the model prediction is transferred to.')
+    parser.add_argument('--with-df', action='store_true', help='Use density fitting for SCF.')
+    parser.add_argument('--with-df-basis', default='def2-svp-jkfit', help='The basis set for density fitting in SCF.')
+    parser.add_argument('--output', required=True, type=str, help='Path to the output CSV file')
+    parser.add_argument('--num-shards', type=int, default=1, help='Number of shards')
+    parser.add_argument('--shard-index', default=0, type=int, help='Shard index')
+    parser.add_argument('--scf-verbose', action='store_true', help='Print SCF verbose information')
+    parser.add_argument('--split', default='no', type=str, choices=['train', 'val', 'test', 'no'], help='Split of the dataset')
+    parser.add_argument('--normalize-nelec', action='store_true', help='Normalize the model prediction by number of electrons.')
+    args = parser.parse_args()
+
+    if not args.gt_mode:
+        assert args.ckpt is not None, 'Checkpoint path is required in non-gt mode.'
+
+        ckpt = torch.load(args.ckpt, map_location='cpu', weights_only=True)
+
+        config = ckpt['config']
+        model = nequip_simple_builder(**config['model'])
+        model.load_state_dict(ckpt['state_dict'])
+        model = model.eval().cuda()
+        data_config = config['data']
+    else:
+        gt_mode_part = 'auxdensity.denfit' if args.model_type == 'auxdensity' else args.model_type
+        data_config = {
+            'r_max': 5.0,
+            'type_names': ['H', 'C', 'N', 'O', 'F', 'P', 'S'],
+            'remove_self_loops': True,
+            'parts_to_load': ['base', gt_mode_part],
+            'aobasis': 'def2-svp',
+            'auxbasis': 'def2-universal-jfit',
+            'use_denfit_ovlp': False,
+        }
+
+    dataset = SCFBenchDataset(data_root=args.data_root, **data_config)
+    if args.split != 'no':
+        print(f'Assuming the dataset is SCFbench-main and using indices from scfbench_main_split.npz for split {args.split}...')
+        split_file = np.load('./scfbench_main_split.npz')
+        dataset_indices = split_file[args.split].tolist()
+    else:
+        dataset_indices = list(range(len(dataset)))
+
+    dataset_subset_indices = [i for i in dataset_indices if i % args.num_shards == args.shard_index]
+    dataloader = DataLoader(
+        Subset(dataset, dataset_subset_indices),
+        batch_size=1,
+        shuffle=False,
+        num_workers=2,
+        collate_fn=dataset.collater,
+    )
+
+    aobasis_name, auxbasis_name = data_config['aobasis'], data_config['auxbasis']
+
+    aobasis = GTOBasis.from_basis_name(aobasis_name, elements=data_config['type_names'])
+    auxbasis = GTOBasis.from_basis_name(auxbasis_name, elements=data_config['type_names'])
+    ao_prod_basis = GTOProductBasisHelper(aobasis)
+
+    use_denfit_ovlp = data_config.get('use_denfit_ovlp', False)
+
+    records = []
+    for data in tqdm.tqdm(dataloader):
+        data = move_data_to_device(data, 'cuda')
+
+        mol = build_mol_from_data(data_config['type_names'], aobasis_name, data)
+        transfer_mol = build_mol_from_data(data_config['type_names'], args.transfer_basis, data) if args.transfer_basis else None
+
+        if not args.gt_mode:
+            model_time = 1000.0
+            while model_time > 1:
+                t0 = time.time()
+                with torch.no_grad():
+                    outputs = model(data)
+                t1 = time.time()
+                model_time = t1 - t0
+        else:
+            if args.model_type == 'auxdensity':
+                outputs = {'output:auxdensity': data['auxdensity']}
+            elif args.model_type == 'fock':
+                outputs = {'output:fock_diag_blocks': data['fock_diag_blocks'], 'output:fock_tril_blocks': data['fock_tril_blocks']}
+            elif args.model_type == 'dm':
+                outputs = {'output:dm_diag_blocks': data['dm_diag_blocks'], 'output:dm_tril_blocks': data['dm_tril_blocks']}
+            model_time = 0.0
+
+        t2 = time.time()
+
+        if args.model_type == 'auxdensity':
+            dm, extra_stats = pred_auxdensity_postprocess(mol, outputs, auxbasis_name, auxbasis, args.xc, use_denfit_ovlp, args.normalize_nelec, transfer_mol=transfer_mol)
+        elif args.model_type == 'fock':
+            dm, extra_stats = pred_fock_postprocess(mol, outputs, ao_prod_basis, args.normalize_nelec, transfer_mol=transfer_mol)
+        elif args.model_type == 'dm':
+            dm, extra_stats = pred_dm_postprocess(mol, outputs, ao_prod_basis, args.normalize_nelec, transfer_mol=transfer_mol)
+
+        t3 = time.time()
+
+        eval_scf = partial(run_scf_and_count_steps, xc=args.xc, verbose=args.scf_verbose, with_df=args.with_df, with_df_basis=args.with_df_basis)
+        if transfer_mol is not None:
+            original_energy, original_steps, original_time = eval_scf(transfer_mol, dm0=None)
+            accelerated_energy, accelerated_steps, accelerated_time = eval_scf(transfer_mol, dm0=cp.array(dm.astype(np.float64)))  # the type conversion is important here
+        else:
+            original_energy, original_steps, original_time = eval_scf(mol, dm0=None)
+            accelerated_energy, accelerated_steps, accelerated_time = eval_scf(mol, dm0=cp.array(dm.astype(np.float64)))  # the type conversion is important here
+
+        record = {
+            'natom': mol.natm,
+            'nelec': mol.nelectron,
+            'original_steps': original_steps,
+            'accelerated_steps': accelerated_steps,
+            'original_time': original_time,
+            'accelerated_time': accelerated_time,
+            'original_energy': original_energy,
+            'accelerated_energy': accelerated_energy,
+            'model_time': model_time,
+            'conversion_time': t3 - t2,
+        }
+        record.update(extra_stats)
+        print(record)
+        records.append(record)
+
+        del data, mol, dm, outputs
+
+        if len(records) % 10 == 0:
+            df = pd.DataFrame.from_records(records)
+            df.to_csv(args.output, index=False)
+
+    df = pd.DataFrame.from_records(records)
+    df.to_csv(args.output, index=False)
+
+
+if __name__ == '__main__':
+    main()

nequip_L_jfit.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c76173949255069cd0862cc2859ebdd4c66d01a97474243946a31ab34f00137
+size 202296215

nequip_model.py

@@ -116,7 +116,6 @@ class NequipArch(nn.Module):
         convnet_nonlinearity_type: str = "gate",
         convnet_nonlinearity_scalars: dict[int, Callable] = {"e": "silu", "o": "tanh"},
         convnet_nonlinearity_gates: dict[int, Callable] = {"e": "silu", "o": "tanh"},
-        task_head_specs: dict[str, Any] = {},
         auxbasis: str = "def2-universal-jfit",
     ):
         super().__init__()

scfbench_main_split.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cf7e22feda869fab3825e53cb5c9d67a079db5cdd79fd505c4bab4982fdc651
+size 351634