nequip_model.py

# Copyright (c) 2021 The President and Fellows of Harvard College
# Copyright (c) 2025 The NequIP Developers
# Copyright (c) 2025 ByteDance Ltd. and/or its affiliates
# SPDX-License-Identifier: MIT
#
# This file has been modified by ByteDance Ltd. and/or its affiliates on 2025-09-01.
#
# Original file was released under MIT, with the full license text
# available at https://github.com/mir-group/nequip/blob/main/LICENSE.
#
# This modified file is released under the same license.

import warnings
from typing import Sequence, Optional, Callable, Any

import math

import torch
import torch.nn as nn
from e3nn import o3
from e3nn.util.jit import compile_mode
from nequip.nn import GraphModuleMixin
from nequip.nn.utils import with_edge_vectors_

from nequip.data import AtomicDataDict
from nequip.nn import (
    SequentialGraphNetwork,
    ConvNetLayer,
    ApplyFactor,
)
from nequip.nn.embedding import (
    EdgeLengthNormalizer,
    BesselEdgeLengthEncoding,
    PolynomialCutoff,
    NodeTypeEmbed,
)

from modules import AuxdensityHeadForNequip

@compile_mode("script")
class SphericalHarmonicEdgeAttrs(GraphModuleMixin, torch.nn.Module):
    """Construct edge attrs as spherical harmonic projections of edge vectors.

    Parameters follow ``e3nn.o3.spherical_harmonics``.

    Args:
        irreps_edge_sh (int, str, or o3.Irreps): if int, will be treated as lmax for o3.Irreps.spherical_harmonics(lmax)
        edge_sh_normalization (str): the normalization scheme to use
        edge_sh_normalize (bool, default: True): whether to normalize the spherical harmonics
        out_field (str, default: AtomicDataDict.EDGE_ATTRS_KEY: data/irreps field
    """

    out_field: str

    def __init__(
        self,
        irreps_edge_sh: int | str | o3.Irreps,
        component_order: str = 'e3nn',
        edge_sh_normalization: str = "component",
        edge_sh_normalize: bool = True,
        irreps_in=None,
        out_field: str = AtomicDataDict.EDGE_ATTRS_KEY,
    ):
        super().__init__()
        self.out_field = out_field

        if isinstance(irreps_edge_sh, int):
            self.irreps_edge_sh = o3.Irreps.spherical_harmonics(irreps_edge_sh)
        else:
            self.irreps_edge_sh = o3.Irreps(irreps_edge_sh)
        self._init_irreps(
            irreps_in=irreps_in,
            irreps_out={out_field: self.irreps_edge_sh},
        )
        self.sh = o3.SphericalHarmonics(
            self.irreps_edge_sh, edge_sh_normalize, edge_sh_normalization
        )
        # i.e. `model_dtype`
        self._output_dtype = torch.get_default_dtype()

        assert component_order in ['e3nn', 'std'], "component_order must be 'e3nn' or 'std'"
        self.component_order = component_order

    def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
        data = with_edge_vectors_(data, with_lengths=False)
        edge_vec = data[AtomicDataDict.EDGE_VECTORS_KEY]
        if self.component_order == 'std':
            edge_vec = edge_vec[:, [1, 2, 0]]
        edge_sh = self.sh(edge_vec)
        data[self.out_field] = edge_sh.to(self._output_dtype)
        return data


class NequipArch(nn.Module):
    def __init__(
        self,
        r_max: float,
        type_names: Sequence[str],
        # convnet params
        radial_mlp_depth: Sequence[int],
        radial_mlp_width: Sequence[int],
        feature_irreps_hidden: Sequence[str | o3.Irreps],
        # irreps and dims
        irreps_edge_sh: int | str | o3.Irreps,
        type_embed_num_features: int,
        # edge length encoding
        per_edge_type_cutoff: Optional[dict[str, float | dict[str, float]]] = None,
        num_bessels: int = 8,
        bessel_trainable: bool = False,
        polynomial_cutoff_p: int = 6,
        # edge sum normalization
        avg_num_neighbors: Optional[float] = None,
        # == things that generally shouldn't be changed ==
        # convnet
        convnet_resnet: bool = False,
        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__()

        self.type_names = type_names

        # === sanity checks and warnings ===
        assert all(tn.isalnum() for tn in type_names), (
            "`type_names` must contain only alphanumeric characters"
        )

        # require every convnet layer to be specified explicitly in a list
        # infer num_layers from the list size
        assert (
            len(radial_mlp_depth) == len(radial_mlp_width) == len(feature_irreps_hidden)
        ), (
            f"radial_mlp_depth: {radial_mlp_depth}, radial_mlp_width: {radial_mlp_width}, feature_irreps_hidden: {feature_irreps_hidden} should all have the same length"
        )
        num_layers = len(radial_mlp_depth)

        if avg_num_neighbors is None:
            warnings.warn(
                "Found `avg_num_neighbors=None` -- it is recommended to set `avg_num_neighbors` for normalization and better numerics during training."
            )

        # === encode and embed features ===
        # == edge tensor embedding ==
        spharm = SphericalHarmonicEdgeAttrs(
            irreps_edge_sh=irreps_edge_sh,
            component_order="std",
        )
        # == edge scalar embedding ==
        edge_norm = EdgeLengthNormalizer(
            r_max=r_max,
            type_names=type_names,
            per_edge_type_cutoff=per_edge_type_cutoff,
            irreps_in=spharm.irreps_out,
        )
        bessel_encode = BesselEdgeLengthEncoding(
            num_bessels=num_bessels,
            trainable=bessel_trainable,
            cutoff=PolynomialCutoff(polynomial_cutoff_p),
            edge_invariant_field=AtomicDataDict.EDGE_EMBEDDING_KEY,
            irreps_in=edge_norm.irreps_out,
        )
        # for backwards compatibility of NequIP's bessel encoding
        factor = ApplyFactor(
            in_field=AtomicDataDict.EDGE_EMBEDDING_KEY,
            factor=(2 * math.pi) / (r_max * r_max),
            irreps_in=bessel_encode.irreps_out,
        )
        # == node scalar embedding ==
        type_embed = NodeTypeEmbed(
            type_names=type_names,
            num_features=type_embed_num_features,
            irreps_in=factor.irreps_out,
        )
        modules = {
            "spharm": spharm,
            "edge_norm": edge_norm,
            "bessel_encode": bessel_encode,
            "factor": factor,
            "type_embed": type_embed,
        }
        prev_irreps_out = type_embed.irreps_out

        # === convnet layers ===
        for layer_i in range(num_layers):
            current_convnet = ConvNetLayer(
                irreps_in=prev_irreps_out,
                feature_irreps_hidden=feature_irreps_hidden[layer_i],
                convolution_kwargs={
                    "radial_mlp_depth": radial_mlp_depth[layer_i],
                    "radial_mlp_width": radial_mlp_width[layer_i],
                    "avg_num_neighbors": avg_num_neighbors,
                    # to ensure isolated atom limit
                    "use_sc": layer_i != 0,
                },
                resnet=(layer_i != 0) and convnet_resnet,
                nonlinearity_type=convnet_nonlinearity_type,
                nonlinearity_scalars=convnet_nonlinearity_scalars,
                nonlinearity_gates=convnet_nonlinearity_gates,
            )
            prev_irreps_out = current_convnet.irreps_out
            modules.update({f"layer{layer_i}_convnet": current_convnet})

        # === assemble in SequentialGraphNetwork ===
        self.backbone = SequentialGraphNetwork(modules)

        # === readout ===
        self.backbone_irreps_out = prev_irreps_out
        self.task_head = SequentialGraphNetwork(
            {
                "auxdensity_atom_readout": AuxdensityHeadForNequip(
                    type_names=self.type_names,
                    auxbasis=auxbasis,
                    field=AtomicDataDict.NODE_FEATURES_KEY,
                    out_field="output:auxdensity",
                    biases=True,
                    irreps_in=self.backbone_irreps_out,
                ),
            }
        )

    def convert_inputs(self, inputs):
        ret = inputs.copy()
        ret.update(
            {
                AtomicDataDict.ATOM_TYPE_KEY: inputs["z"],
                AtomicDataDict.POSITIONS_KEY: inputs["pos"],
                AtomicDataDict.EDGE_INDEX_KEY: inputs["edge_index"],
            }
        )
        return ret

    def forward(self, data):
        data = self.convert_inputs(data)
        data = self.backbone(data)
        data = self.task_head(data)
        return data


def nequip_simple_builder(
    num_layers: int = 4,
    l_max: int = 1,
    parity: bool = True,
    num_features: int = 32,
    radial_mlp_depth: int = 2,
    radial_mlp_width: int = 64,
    **kwargs,
) -> nn.Module:
    irreps_edge_sh = repr(
        o3.Irreps.spherical_harmonics(lmax=l_max, p=-1 if parity else 1)
    )
    feature_irreps_hidden = repr(
        o3.Irreps(
            [
                (num_features, (l, p))
                for p in ((1, -1) if parity else (1,))
                for l in range(l_max + 1)
            ]
        )
    )
    feature_irreps_hidden_list = [feature_irreps_hidden] * (num_layers - 1)
    radial_mlp_depth_list = [radial_mlp_depth] * num_layers
    radial_mlp_width_list = [radial_mlp_width] * num_layers

    feature_irreps_hidden_list += [feature_irreps_hidden]

    model = NequipArch(
        irreps_edge_sh=irreps_edge_sh,
        type_embed_num_features=num_features,
        feature_irreps_hidden=feature_irreps_hidden_list,
        radial_mlp_depth=radial_mlp_depth_list,
        radial_mlp_width=radial_mlp_width_list,
        **kwargs,
    )
    return model


if __name__ == "__main__":
    model = nequip_simple_builder(r_max=5.0, type_names=["H", "C", "N", "O", "F", "P", "S"])
    from dataset import SCFBenchDataset
    dataset = SCFBenchDataset("dataset/main", parts_to_load=["base", "auxdensity.denfit"])
    print(model(dataset[0])['output:auxdensity'])