diff --git a/dptb/data/AtomicData.py b/dptb/data/AtomicData.py
new file mode 100644
index 00000000..0163a457
--- /dev/null
+++ b/dptb/data/AtomicData.py
@@ -0,0 +1,993 @@
+"""AtomicData: neighbor graphs in (periodic) real space.
+
+Authors: Albert Musaelian
+"""
+
+import warnings
+from copy import deepcopy
+from typing import Union, Tuple, Dict, Optional, List, Set, Sequence
+from collections.abc import Mapping
+import os
+
+import numpy as np
+import ase.neighborlist
+import ase
+from ase.calculators.singlepoint import SinglePointCalculator, SinglePointDFTCalculator
+from ase.calculators.calculator import all_properties as ase_all_properties
+from ase.stress import voigt_6_to_full_3x3_stress, full_3x3_to_voigt_6_stress
+
+import torch
+import e3nn.o3
+
+from . import AtomicDataDict
+from .util import _TORCH_INTEGER_DTYPES
+from dptb.utils.torch_geometric.data import Data
+
+# A type representing ASE-style periodic boundary condtions, which can be partial (the tuple case)
+PBC = Union[bool, Tuple[bool, bool, bool]]
+
+
+_DEFAULT_LONG_FIELDS: Set[str] = {
+ AtomicDataDict.EDGE_INDEX_KEY,
+ AtomicDataDict.ENV_INDEX_KEY, # new
+ AtomicDataDict.ONSITENV_INDEX_KEY, # new
+ AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ AtomicDataDict.ATOM_TYPE_KEY,
+ AtomicDataDict.BATCH_KEY,
+}
+
+_DEFAULT_NODE_FIELDS: Set[str] = {
+ AtomicDataDict.POSITIONS_KEY,
+ AtomicDataDict.NODE_FEATURES_KEY,
+ AtomicDataDict.NODE_ATTRS_KEY,
+ AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ AtomicDataDict.ATOM_TYPE_KEY,
+ AtomicDataDict.FORCE_KEY,
+ AtomicDataDict.PER_ATOM_ENERGY_KEY,
+ AtomicDataDict.NODE_HAMILTONIAN_KEY,
+ AtomicDataDict.NODE_OVERLAP_KEY,
+ AtomicDataDict.BATCH_KEY,
+}
+
+_DEFAULT_EDGE_FIELDS: Set[str] = {
+ AtomicDataDict.EDGE_CELL_SHIFT_KEY,
+ AtomicDataDict.EDGE_VECTORS_KEY,
+ AtomicDataDict.EDGE_LENGTH_KEY,
+ AtomicDataDict.EDGE_ATTRS_KEY,
+ AtomicDataDict.EDGE_EMBEDDING_KEY,
+ AtomicDataDict.EDGE_FEATURES_KEY,
+ AtomicDataDict.EDGE_CUTOFF_KEY,
+ AtomicDataDict.EDGE_ENERGY_KEY,
+ AtomicDataDict.EDGE_OVERLAP_KEY,
+ AtomicDataDict.EDGE_HAMILTONIAN_KEY,
+ AtomicDataDict.EDGE_TYPE_KEY,
+}
+
+_DEFAULT_ENV_FIELDS: Set[str] = {
+ AtomicDataDict.ENV_CELL_SHIFT_KEY,
+ AtomicDataDict.ENV_VECTORS_KEY,
+ AtomicDataDict.ENV_LENGTH_KEY,
+ AtomicDataDict.ENV_ATTRS_KEY,
+ AtomicDataDict.ENV_EMBEDDING_KEY,
+ AtomicDataDict.ENV_FEATURES_KEY,
+ AtomicDataDict.ENV_CUTOFF_KEY,
+}
+
+_DEFAULT_ONSITENV_FIELDS: Set[str] = {
+ AtomicDataDict.ONSITENV_CELL_SHIFT_KEY,
+ AtomicDataDict.ONSITENV_VECTORS_KEY,
+ AtomicDataDict.ONSITENV_LENGTH_KEY,
+ AtomicDataDict.ONSITENV_ATTRS_KEY,
+ AtomicDataDict.ONSITENV_EMBEDDING_KEY,
+ AtomicDataDict.ONSITENV_FEATURES_KEY,
+ AtomicDataDict.ONSITENV_CUTOFF_KEY,
+}
+
+_DEFAULT_GRAPH_FIELDS: Set[str] = {
+ AtomicDataDict.TOTAL_ENERGY_KEY,
+ AtomicDataDict.STRESS_KEY,
+ AtomicDataDict.VIRIAL_KEY,
+ AtomicDataDict.PBC_KEY,
+ AtomicDataDict.CELL_KEY,
+ AtomicDataDict.BATCH_PTR_KEY,
+ AtomicDataDict.KPOINT_KEY, # new
+ AtomicDataDict.HAMILTONIAN_KEY, # new
+ AtomicDataDict.OVERLAP_KEY, # new
+ AtomicDataDict.ENERGY_EIGENVALUE_KEY, # new
+ AtomicDataDict.ENERGY_WINDOWS_KEY, # new,
+ AtomicDataDict.BAND_WINDOW_KEY # new,
+}
+
+_NODE_FIELDS: Set[str] = set(_DEFAULT_NODE_FIELDS)
+_EDGE_FIELDS: Set[str] = set(_DEFAULT_EDGE_FIELDS)
+_ENV_FIELDS: Set[str] = set(_DEFAULT_ENV_FIELDS)
+_ONSITENV_FIELDS: Set[str] = set(_DEFAULT_ONSITENV_FIELDS)
+_GRAPH_FIELDS: Set[str] = set(_DEFAULT_GRAPH_FIELDS)
+_LONG_FIELDS: Set[str] = set(_DEFAULT_LONG_FIELDS)
+
+
+def register_fields(
+ node_fields: Sequence[str] = [],
+ edge_fields: Sequence[str] = [],
+ env_fields: Sequence[str] = [],
+ onsitenv_fields: Sequence[str] = [],
+ graph_fields: Sequence[str] = [],
+ long_fields: Sequence[str] = [],
+) -> None:
+
+ r"""Register fields as being per-atom, per-edge, or per-frame.
+
+ Args:
+ node_permute_fields: fields that are equivariant to node permutations.
+ edge_permute_fields: fields that are equivariant to edge permutations.
+ """
+
+ node_fields: set = set(node_fields)
+ edge_fields: set = set(edge_fields)
+ env_fields: set = set(env_fields)
+ onsitenv_fields: set = set(onsitenv_fields)
+ graph_fields: set = set(graph_fields)
+ long_fields: set = set(long_fields)
+ allfields = node_fields.union(edge_fields, graph_fields, env_fields, onsitenv_fields)
+ assert len(allfields) == len(node_fields) + len(edge_fields) + len(graph_fields)
+ _NODE_FIELDS.update(node_fields)
+ _EDGE_FIELDS.update(edge_fields)
+ _ENV_FIELDS.update(env_fields)
+ _ONSITENV_FIELDS.update(onsitenv_fields)
+ _GRAPH_FIELDS.update(graph_fields)
+ _LONG_FIELDS.update(long_fields)
+ if len(set.union(_NODE_FIELDS, _EDGE_FIELDS, _GRAPH_FIELDS)) < (
+ len(_NODE_FIELDS) + len(_EDGE_FIELDS) + len(_GRAPH_FIELDS)
+ ):
+ raise ValueError(
+ "At least one key was registered as more than one of node, edge, or graph!"
+ )
+
+
+def deregister_fields(*fields: Sequence[str]) -> None:
+ r"""Deregister a field registered with ``register_fields``.
+
+ Silently ignores fields that were never registered to begin with.
+
+ Args:
+ *fields: fields to deregister.
+ """
+ for f in fields:
+ assert f not in _DEFAULT_NODE_FIELDS, "Cannot deregister built-in field"
+ assert f not in _DEFAULT_EDGE_FIELDS, "Cannot deregister built-in field"
+ assert f not in _DEFAULT_GRAPH_FIELDS, "Cannot deregister built-in field"
+ assert f not in _DEFAULT_ENV_FIELDS, "Cannot deregister built-in field"
+ assert f not in _DEFAULT_ONSITENV_FIELDS, "Cannot deregister built-in field"
+ _NODE_FIELDS.discard(f)
+ _EDGE_FIELDS.discard(f)
+ _ENV_FIELDS.discard(f)
+ _ONSITENV_FIELDS.discard(f)
+ _GRAPH_FIELDS.discard(f)
+
+
+def _register_field_prefix(prefix: str) -> None:
+ """Re-register all registered fields as the same type, but with `prefix` added on."""
+ assert prefix.endswith("_")
+ register_fields(
+ node_fields=[prefix + e for e in _NODE_FIELDS],
+ edge_fields=[prefix + e for e in _EDGE_FIELDS],
+ env_fields=[prefix + e for e in _ENV_FIELDS],
+ onsitenv_fields=[prefix + e for e in _ONSITENV_FIELDS],
+ graph_fields=[prefix + e for e in _GRAPH_FIELDS],
+ long_fields=[prefix + e for e in _LONG_FIELDS],
+ )
+
+
+def _process_dict(kwargs, ignore_fields=[]):
+ """Convert a dict of data into correct dtypes/shapes according to key"""
+ # Deal with _some_ dtype issues
+ for k, v in kwargs.items():
+ if k in ignore_fields:
+ continue
+
+ if k in _LONG_FIELDS:
+ # Any property used as an index must be long (or byte or bool, but those are not relevant for atomic scale systems)
+ # int32 would pass later checks, but is actually disallowed by torch
+ kwargs[k] = torch.as_tensor(v, dtype=torch.long)
+ elif isinstance(v, bool):
+ kwargs[k] = torch.as_tensor(v)
+ elif isinstance(v, np.ndarray):
+ if np.issubdtype(v.dtype, np.floating):
+ kwargs[k] = torch.as_tensor(v, dtype=torch.get_default_dtype())
+ else:
+ kwargs[k] = torch.as_tensor(v)
+ elif isinstance(v, list):
+ ele_dtype = np.array(v).dtype
+ if np.issubdtype(ele_dtype, np.floating):
+ kwargs[k] = torch.as_tensor(v, dtype=torch.get_default_dtype())
+ else:
+ kwargs[k] = torch.as_tensor(v)
+ elif np.issubdtype(type(v), np.floating):
+ # Force scalars to be tensors with a data dimension
+ # This makes them play well with irreps
+ kwargs[k] = torch.as_tensor(v, dtype=torch.get_default_dtype())
+ elif isinstance(v, torch.Tensor) and len(v.shape) == 0:
+ # ^ this tensor is a scalar; we need to give it
+ # a data dimension to play nice with irreps
+ kwargs[k] = v
+
+ if AtomicDataDict.BATCH_KEY in kwargs:
+ num_frames = kwargs[AtomicDataDict.BATCH_KEY].max() + 1
+ else:
+ num_frames = 1
+
+ for k, v in kwargs.items():
+ if k in ignore_fields:
+ continue
+
+ if len(v.shape) == 0:
+ kwargs[k] = v.unsqueeze(-1)
+ v = kwargs[k]
+
+ if k in set.union(_NODE_FIELDS, _EDGE_FIELDS) and len(v.shape) == 1:
+ kwargs[k] = v.unsqueeze(-1)
+ v = kwargs[k]
+
+ if (
+ k in _NODE_FIELDS
+ and AtomicDataDict.POSITIONS_KEY in kwargs
+ and v.shape[0] != kwargs[AtomicDataDict.POSITIONS_KEY].shape[0]
+ ):
+ raise ValueError(
+ f"{k} is a node field but has the wrong dimension {v.shape}"
+ )
+ elif (
+ k in _EDGE_FIELDS
+ and AtomicDataDict.EDGE_INDEX_KEY in kwargs
+ and v.shape[0] != kwargs[AtomicDataDict.EDGE_INDEX_KEY].shape[1]
+ ):
+ raise ValueError(
+ f"{k} is a edge field but has the wrong dimension {v.shape}"
+ )
+ elif (
+ k in _ENV_FIELDS
+ and AtomicDataDict.ENV_INDEX_KEY in kwargs
+ and v.shape[0] != kwargs[AtomicDataDict.ENV_INDEX_KEY].shape[1]
+ ):
+ raise ValueError(
+ f"{k} is a env field but has the wrong dimension {v.shape}"
+ )
+ elif (
+ k in _ONSITENV_FIELDS
+ and AtomicDataDict.ONSITENV_INDEX_KEY in kwargs
+ and v.shape[0] != kwargs[AtomicDataDict.ONSITENV_INDEX_KEY].shape[1]
+ ):
+ raise ValueError(
+ f"{k} is a env field but has the wrong dimension {v.shape}"
+ )
+ elif k in _GRAPH_FIELDS:
+ if num_frames > 1 and v.shape[0] != num_frames:
+ raise ValueError(f"Wrong shape for graph property {k}")
+
+
+class AtomicData(Data):
+ """A neighbor graph for points in (periodic triclinic) real space.
+
+ For typical cases either ``from_points`` or ``from_ase`` should be used to
+ construct a AtomicData; they also standardize and check their input much more
+ thoroughly.
+
+ In general, ``node_features`` are features or input information on the nodes that will be fed through and transformed by the network, while ``node_attrs`` are _encodings_ fixed, inherant attributes of the atoms themselves that remain constant through the network.
+ For example, a one-hot _encoding_ of atomic species is a node attribute, while some observed instantaneous property of that atom (current partial charge, for example), would be a feature.
+
+ In general, ``torch.Tensor`` arguments should be of consistant dtype. Numpy arrays will be converted to ``torch.Tensor``s; those of floating point dtype will be converted to ``torch.get_current_dtype()`` regardless of their original precision. Scalar values (Python scalars or ``torch.Tensor``s of shape ``()``) a resized to tensors of shape ``[1]``. Per-atom scalar values should be given with shape ``[N_at, 1]``.
+
+ ``AtomicData`` should be used for all data creation and manipulation outside of the model; inside of the model ``AtomicDataDict.Type`` is used.
+
+ Args:
+ pos (Tensor [n_nodes, 3]): Positions of the nodes.
+ edge_index (LongTensor [2, n_edges]): ``edge_index[0]`` is the per-edge
+ index of the source node and ``edge_index[1]`` is the target node.
+ edge_cell_shift (Tensor [n_edges, 3], optional): which periodic image
+ of the target point each edge goes to, relative to the source point.
+ cell (Tensor [1, 3, 3], optional): the periodic cell for
+ ``edge_cell_shift`` as the three triclinic cell vectors.
+ node_features (Tensor [n_atom, ...]): the input features of the nodes, optional
+ node_attrs (Tensor [n_atom, ...]): the attributes of the nodes, for instance the atom type, optional
+ batch (Tensor [n_atom]): the graph to which the node belongs, optional
+ atomic_numbers (Tensor [n_atom]): optional.
+ atom_type (Tensor [n_atom]): optional.
+ **kwargs: other data, optional.
+ """
+
+ def __init__(
+ self, irreps: Dict[str, e3nn.o3.Irreps] = {}, _validate: bool = True, **kwargs
+ ):
+
+ # empty init needed by get_example
+ if len(kwargs) == 0 and len(irreps) == 0:
+ super().__init__()
+ return
+
+ # Check the keys
+ if _validate:
+ AtomicDataDict.validate_keys(kwargs)
+ _process_dict(kwargs)
+
+ super().__init__(num_nodes=len(kwargs["pos"]), **kwargs)
+
+ if _validate:
+ # Validate shapes
+ assert self.pos.dim() == 2 and self.pos.shape[1] == 3
+ assert self.edge_index.dim() == 2 and self.edge_index.shape[0] == 2
+ if "edge_cell_shift" in self and self.edge_cell_shift is not None:
+ assert self.edge_cell_shift.shape == (self.num_edges, 3)
+ assert self.edge_cell_shift.dtype == self.pos.dtype
+ # TODO: should we add checks for env too ?
+ if "cell" in self and self.cell is not None:
+ assert (self.cell.shape == (3, 3)) or (
+ self.cell.dim() == 3 and self.cell.shape[1:] == (3, 3)
+ )
+ assert self.cell.dtype == self.pos.dtype
+ if "node_features" in self and self.node_features is not None:
+ assert self.node_features.shape[0] == self.num_nodes
+ assert self.node_features.dtype == self.pos.dtype
+ if "node_attrs" in self and self.node_attrs is not None:
+ assert self.node_attrs.shape[0] == self.num_nodes
+ assert self.node_attrs.dtype == self.pos.dtype
+
+ if (
+ AtomicDataDict.ATOMIC_NUMBERS_KEY in self
+ and self.atomic_numbers is not None
+ ):
+ assert self.atomic_numbers.dtype in _TORCH_INTEGER_DTYPES
+ if "batch" in self and self.batch is not None:
+ assert self.batch.dim() == 2 and self.batch.shape[0] == self.num_nodes
+ # Check that there are the right number of cells
+ if "cell" in self and self.cell is not None:
+ cell = self.cell.view(-1, 3, 3)
+ assert cell.shape[0] == self.batch.max() + 1
+
+ # Validate irreps
+ # __*__ is the only way to hide from torch_geometric
+ self.__irreps__ = AtomicDataDict._fix_irreps_dict(irreps)
+ for field, irreps in self.__irreps__:
+ if irreps is not None:
+ assert self[field].shape[-1] == irreps.dim
+
+ @classmethod
+ def from_points(
+ cls,
+ pos=None,
+ r_max: float = None,
+ self_interaction: bool = False,
+ cell=None,
+ pbc: Optional[PBC] = None,
+ er_max: Optional[float] = None,
+ oer_max: Optional[float] = None,
+ **kwargs,
+ ):
+ """Build neighbor graph from points, optionally with PBC.
+
+ Args:
+ pos (np.ndarray/torch.Tensor shape [N, 3]): node positions. If Tensor, must be on the CPU.
+ r_max (float): neighbor cutoff radius.
+ cell (ase.Cell/ndarray [3,3], optional): periodic cell for the points. Defaults to ``None``.
+ pbc (bool or 3-tuple of bool, optional): whether to apply periodic boundary conditions to all or each of
+ the three cell vector directions. Defaults to ``False``.
+ self_interaction (bool, optional): whether to include self edges for points. Defaults to ``False``. Note
+ that edges between the same atom in different periodic images are still included. (See
+ ``strict_self_interaction`` to control this behaviour.)
+ strict_self_interaction (bool): Whether to include *any* self interaction edges in the graph, even if the
+ two instances of the atom are in different periodic images. Defaults to True, should be True for most
+ applications.
+ **kwargs (optional): other fields to add. Keys listed in ``AtomicDataDict.*_KEY` will be treated specially.
+ """
+ if pos is None or r_max is None:
+ raise ValueError("pos and r_max must be given.")
+
+ if pbc is None:
+ if cell is not None:
+ raise ValueError(
+ "A cell was provided, but pbc weren't. Please explicitly probide PBC."
+ )
+ # there are no PBC if cell and pbc are not provided
+ pbc = False
+
+ if isinstance(pbc, bool):
+ pbc = (pbc,) * 3
+ else:
+ assert len(pbc) == 3
+
+ # TODO: We can only compute the edge vector one times with the largest radial distance among [r_max, er_max, oer_max]
+
+ pos = torch.as_tensor(pos, dtype=torch.get_default_dtype())
+
+ edge_index, edge_cell_shift, cell = neighbor_list_and_relative_vec(
+ pos=pos,
+ r_max=r_max,
+ self_interaction=self_interaction,
+ cell=cell,
+ reduce=False,
+ atomic_numbers=kwargs.get("atomic_numbers", None),
+ pbc=pbc,
+ )
+
+ # Make torch tensors for data:
+ if cell is not None:
+ kwargs[AtomicDataDict.CELL_KEY] = cell.view(3, 3)
+ kwargs[AtomicDataDict.EDGE_CELL_SHIFT_KEY] = edge_cell_shift
+ if pbc is not None:
+ kwargs[AtomicDataDict.PBC_KEY] = torch.as_tensor(
+ pbc, dtype=torch.bool
+ ).view(3)
+
+ # add env index
+ if er_max is not None:
+ env_index, env_cell_shift, _ = neighbor_list_and_relative_vec(
+ pos=pos,
+ r_max=er_max,
+ self_interaction=self_interaction,
+ cell=cell,
+ reduce=False,
+ atomic_numbers=kwargs.get("atomic_numbers", None),
+ pbc=pbc,
+ )
+
+ if cell is not None:
+ kwargs[AtomicDataDict.ENV_CELL_SHIFT_KEY] = env_cell_shift
+ kwargs[AtomicDataDict.ENV_INDEX_KEY] = env_index
+
+ # add onsitenv index
+ if oer_max is not None:
+ onsitenv_index, onsitenv_cell_shift, _ = neighbor_list_and_relative_vec(
+ pos=pos,
+ r_max=oer_max,
+ self_interaction=self_interaction,
+ cell=cell,
+ reduce=False,
+ atomic_numbers=kwargs.get("atomic_numbers", None),
+ pbc=pbc
+ )
+
+ if cell is not None:
+ kwargs[AtomicDataDict.ONSITENV_CELL_SHIFT_KEY] = onsitenv_cell_shift
+ kwargs[AtomicDataDict.ONSITENV_INDEX_KEY] = onsitenv_index
+
+ return cls(edge_index=edge_index, pos=torch.as_tensor(pos), **kwargs)
+
+ @classmethod
+ def from_ase(
+ cls,
+ atoms,
+ r_max,
+ er_max: Optional[float] = None,
+ oer_max: Optional[float] = None,
+ key_mapping: Optional[Dict[str, str]] = {},
+ include_keys: Optional[list] = [],
+ **kwargs,
+ ):
+ """Build a ``AtomicData`` from an ``ase.Atoms`` object.
+
+ Respects ``atoms``'s ``pbc`` and ``cell``.
+
+ First tries to extract energies and forces from a single-point calculator associated with the ``Atoms`` if one is present and has those fields.
+ If either is not found, the method will look for ``energy``/``energies`` and ``force``/``forces`` in ``atoms.arrays``.
+
+ `get_atomic_numbers()` will be stored as the atomic_numbers attribute.
+
+ Args:
+ atoms (ase.Atoms): the input.
+ r_max (float): neighbor cutoff radius.
+ features (torch.Tensor shape [N, M], optional): per-atom M-dimensional feature vectors. If ``None`` (the
+ default), uses a one-hot encoding of the species present in ``atoms``.
+ include_keys (list): list of additional keys to include in AtomicData aside from the ones defined in
+ ase.calculators.calculator.all_properties. Optional
+ key_mapping (dict): rename ase property name to a new string name. Optional
+ **kwargs (optional): other arguments for the ``AtomicData`` constructor.
+
+ Returns:
+ A ``AtomicData``.
+ """
+ # from nequip.ase import NequIPCalculator
+
+ assert "pos" not in kwargs
+
+ default_args = set(
+ [
+ "numbers",
+ "positions",
+ ] # ase internal names for position and atomic_numbers
+ + ["pbc", "cell", "pos", "r_max", "er_max", "oer_max"] # arguments for from_points method
+ + list(kwargs.keys())
+ )
+ # the keys that are duplicated in kwargs are removed from the include_keys
+ include_keys = list(
+ set(include_keys + ase_all_properties + list(key_mapping.keys()))
+ - default_args
+ )
+
+ km = {
+ "forces": AtomicDataDict.FORCE_KEY,
+ "energy": AtomicDataDict.TOTAL_ENERGY_KEY,
+ }
+ km.update(key_mapping)
+ key_mapping = km
+
+ add_fields = {}
+
+ # Get info from atoms.arrays; lowest priority. copy first
+ add_fields = {
+ key_mapping.get(k, k): v
+ for k, v in atoms.arrays.items()
+ if k in include_keys
+ }
+
+ # Get info from atoms.info; second lowest priority.
+ add_fields.update(
+ {
+ key_mapping.get(k, k): v
+ for k, v in atoms.info.items()
+ if k in include_keys
+ }
+ )
+
+ # if atoms.calc is not None:
+
+ # if isinstance(
+ # atoms.calc, (SinglePointCalculator, SinglePointDFTCalculator)
+ # ):
+ # add_fields.update(
+ # {
+ # key_mapping.get(k, k): deepcopy(v)
+ # for k, v in atoms.calc.results.items()
+ # if k in include_keys
+ # }
+ # )
+ # elif isinstance(atoms.calc, NequIPCalculator):
+ # pass # otherwise the calculator breaks
+ # else:
+ # raise NotImplementedError(
+ # f"`from_ase` does not support calculator {atoms.calc}"
+ # )
+
+ add_fields[AtomicDataDict.ATOMIC_NUMBERS_KEY] = atoms.get_atomic_numbers()
+
+ # cell and pbc in kwargs can override the ones stored in atoms
+ cell = kwargs.pop("cell", atoms.get_cell())
+ pbc = kwargs.pop("pbc", atoms.pbc)
+
+ # handle ASE-style 6 element Voigt order stress
+ for key in (AtomicDataDict.STRESS_KEY, AtomicDataDict.VIRIAL_KEY):
+ if key in add_fields:
+ if add_fields[key].shape == (3, 3):
+ # it's already 3x3, do nothing else
+ pass
+ elif add_fields[key].shape == (6,):
+ # it's Voigt order
+ add_fields[key] = voigt_6_to_full_3x3_stress(add_fields[key])
+ else:
+ raise RuntimeError(f"bad shape for {key}")
+
+ return cls.from_points(
+ pos=atoms.positions,
+ r_max=r_max,
+ er_max=er_max,
+ oer_max=oer_max,
+ cell=cell,
+ pbc=pbc,
+ **kwargs,
+ **add_fields,
+ )
+
+ def to_ase(
+ self,
+ type_mapper=None,
+ extra_fields: List[str] = [],
+ ) -> Union[List[ase.Atoms], ase.Atoms]:
+ """Build a (list of) ``ase.Atoms`` object(s) from an ``AtomicData`` object.
+
+ For each unique batch number provided in ``AtomicDataDict.BATCH_KEY``,
+ an ``ase.Atoms`` object is created. If ``AtomicDataDict.BATCH_KEY`` does not
+ exist in self, a single ``ase.Atoms`` object is created.
+
+ Args:
+ type_mapper: if provided, will be used to map ``ATOM_TYPES`` back into
+ elements, if the configuration of the ``type_mapper`` allows.
+ extra_fields: fields other than those handled explicitly (currently
+ those defining the structure as well as energy, per-atom energy,
+ and forces) to include in the output object. Per-atom (per-node)
+ quantities will be included in ``arrays``; per-graph and per-edge
+ quantities will be included in ``info``.
+
+ Returns:
+ A list of ``ase.Atoms`` objects if ``AtomicDataDict.BATCH_KEY`` is in self
+ and is not None. Otherwise, a single ``ase.Atoms`` object is returned.
+ """
+ positions = self.pos
+ edge_index = self[AtomicDataDict.EDGE_INDEX_KEY]
+ if positions.device != torch.device("cpu"):
+ raise TypeError(
+ "Explicitly move this `AtomicData` to CPU using `.to()` before calling `to_ase()`."
+ )
+ if AtomicDataDict.ATOMIC_NUMBERS_KEY in self:
+ atomic_nums = self.atomic_numbers
+ elif type_mapper is not None and type_mapper.has_chemical_symbols:
+ atomic_nums = type_mapper.untransform(self[AtomicDataDict.ATOM_TYPE_KEY])
+ else:
+ warnings.warn(
+ "AtomicData.to_ase(): self didn't contain atomic numbers... using atom_type as atomic numbers instead, but this means the chemical symbols in ASE (outputs) will be wrong"
+ )
+ atomic_nums = self[AtomicDataDict.ATOM_TYPE_KEY]
+ pbc = getattr(self, AtomicDataDict.PBC_KEY, None)
+ cell = getattr(self, AtomicDataDict.CELL_KEY, None)
+ batch = getattr(self, AtomicDataDict.BATCH_KEY, None)
+ energy = getattr(self, AtomicDataDict.TOTAL_ENERGY_KEY, None)
+ energies = getattr(self, AtomicDataDict.PER_ATOM_ENERGY_KEY, None)
+ force = getattr(self, AtomicDataDict.FORCE_KEY, None)
+ do_calc = any(
+ k in self
+ for k in [
+ AtomicDataDict.TOTAL_ENERGY_KEY,
+ AtomicDataDict.FORCE_KEY,
+ AtomicDataDict.PER_ATOM_ENERGY_KEY,
+ AtomicDataDict.STRESS_KEY,
+ ]
+ )
+
+ # exclude those that are special for ASE and that we process seperately
+ special_handling_keys = [
+ AtomicDataDict.POSITIONS_KEY,
+ AtomicDataDict.CELL_KEY,
+ AtomicDataDict.PBC_KEY,
+ AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ AtomicDataDict.TOTAL_ENERGY_KEY,
+ AtomicDataDict.FORCE_KEY,
+ AtomicDataDict.PER_ATOM_ENERGY_KEY,
+ AtomicDataDict.STRESS_KEY,
+ ]
+ assert (
+ len(set(extra_fields).intersection(special_handling_keys)) == 0
+ ), f"Cannot specify keys handled in special ways ({special_handling_keys}) as `extra_fields` for atoms output--- they are output by default"
+
+ if cell is not None:
+ cell = cell.view(-1, 3, 3)
+ if pbc is not None:
+ pbc = pbc.view(-1, 3)
+
+ if batch is not None:
+ n_batches = batch.max() + 1
+ cell = cell.expand(n_batches, 3, 3) if cell is not None else None
+ pbc = pbc.expand(n_batches, 3) if pbc is not None else None
+ else:
+ n_batches = 1
+
+ batch_atoms = []
+ for batch_idx in range(n_batches):
+ if batch is not None:
+ mask = batch == batch_idx
+ mask = mask.view(-1)
+ # if both ends of the edge are in the batch, the edge is in the batch
+ edge_mask = mask[edge_index[0]] & mask[edge_index[1]]
+ else:
+ mask = slice(None)
+ edge_mask = slice(None)
+
+ mol = ase.Atoms(
+ numbers=atomic_nums[mask].view(-1), # must be flat for ASE
+ positions=positions[mask],
+ cell=cell[batch_idx] if cell is not None else None,
+ pbc=pbc[batch_idx] if pbc is not None else None,
+ )
+
+ if do_calc:
+ fields = {}
+ if energies is not None:
+ fields["energies"] = energies[mask].cpu().numpy()
+ if energy is not None:
+ fields["energy"] = energy[batch_idx].cpu().numpy()
+ if force is not None:
+ fields["forces"] = force[mask].cpu().numpy()
+ if AtomicDataDict.STRESS_KEY in self:
+ fields["stress"] = full_3x3_to_voigt_6_stress(
+ self["stress"].view(-1, 3, 3)[batch_idx].cpu().numpy()
+ )
+ mol.calc = SinglePointCalculator(mol, **fields)
+
+ # add other information
+ for key in extra_fields:
+ if key in _NODE_FIELDS:
+ # mask it
+ mol.arrays[key] = (
+ self[key][mask].cpu().numpy().reshape(mask.sum(), -1)
+ )
+ elif key in _EDGE_FIELDS:
+ mol.info[key] = (
+ self[key][edge_mask].cpu().numpy().reshape(edge_mask.sum(), -1)
+ )
+ elif key == AtomicDataDict.EDGE_INDEX_KEY:
+ mol.info[key] = self[key][:, edge_mask].cpu().numpy()
+ elif key in _GRAPH_FIELDS:
+ mol.info[key] = self[key][batch_idx].cpu().numpy().reshape(-1)
+ else:
+ raise RuntimeError(
+ f"Extra field `{key}` isn't registered as node/edge/graph"
+ )
+
+ batch_atoms.append(mol)
+
+ if batch is not None:
+ return batch_atoms
+ else:
+ assert len(batch_atoms) == 1
+ return batch_atoms[0]
+
+ def get_edge_vectors(data: Data) -> torch.Tensor:
+ data = AtomicDataDict.with_edge_vectors(AtomicData.to_AtomicDataDict(data))
+ return data[AtomicDataDict.EDGE_VECTORS_KEY]
+
+ def get_env_vectors(data: Data) -> torch.Tensor:
+ data = AtomicDataDict.with_env_vectors(AtomicData.to_AtomicDataDict(data))
+ return data[AtomicDataDict.ENV_VECTORS_KEY]
+
+ @staticmethod
+ def to_AtomicDataDict(
+ data: Union[Data, Mapping], exclude_keys=tuple()
+ ) -> AtomicDataDict.Type:
+ if isinstance(data, Data):
+ keys = data.keys
+ elif isinstance(data, Mapping):
+ keys = data.keys()
+ else:
+ raise ValueError(f"Invalid data `{repr(data)}`")
+
+ return {
+ k: data[k]
+ for k in keys
+ if (
+ k not in exclude_keys
+ and data[k] is not None
+ and isinstance(data[k], torch.Tensor)
+ )
+ }
+
+ @classmethod
+ def from_AtomicDataDict(cls, data: AtomicDataDict.Type):
+ # it's an AtomicDataDict, so don't validate-- assume valid:
+ return cls(_validate=False, **data)
+
+ @property
+ def irreps(self):
+ return self.__irreps__
+
+ def __cat_dim__(self, key, value):
+ if key == AtomicDataDict.EDGE_INDEX_KEY or key == AtomicDataDict.ENV_INDEX_KEY or key == AtomicDataDict.ONSITENV_INDEX_KEY:
+ return 1 # always cat in the edge dimension
+ elif key in _GRAPH_FIELDS:
+ # graph-level properties and so need a new batch dimension
+ return None
+ else:
+ return 0 # cat along node/edge dimension
+
+ def without_nodes(self, which_nodes):
+ """Return a copy of ``self`` with ``which_nodes`` removed.
+ The returned object may share references to some underlying data tensors with ``self``.
+ Args:
+ which_nodes (index tensor or boolean mask)
+ Returns:
+ A new data object.
+ """
+ which_nodes = torch.as_tensor(which_nodes)
+ if which_nodes.dtype == torch.bool:
+ mask = ~which_nodes
+ else:
+ mask = torch.ones(self.num_nodes, dtype=torch.bool)
+ mask[which_nodes] = False
+ assert mask.shape == (self.num_nodes,)
+ n_keeping = mask.sum()
+
+ # Only keep edges where both from and to are kept
+ edge_mask = mask[self.edge_index[0]] & mask[self.edge_index[1]]
+ if hasattr(self, AtomicDataDict.ENV_INDEX_KEY):
+ env_mask = mask[self.env_index[0]] & mask[self.env_index[1]]
+ if hasattr(self, AtomicDataDict.ONSITENV_INDEX_KEY):
+ onsitenv_mask = mask[self.onsitenv_index[0]] & mask[self.onsitenv_index[1]]
+ # Create an index mapping:
+ new_index = torch.full((self.num_nodes,), -1, dtype=torch.long)
+ new_index[mask] = torch.arange(n_keeping, dtype=torch.long)
+
+ new_dict = {}
+ for k in self.keys:
+ if k == AtomicDataDict.EDGE_INDEX_KEY:
+ new_dict[AtomicDataDict.EDGE_INDEX_KEY] = new_index[
+ self.edge_index[:, edge_mask]
+ ]
+ elif k == AtomicDataDict.EDGE_CELL_SHIFT_KEY:
+ new_dict[AtomicDataDict.EDGE_CELL_SHIFT_KEY] = self.edge_cell_shift[
+ edge_mask
+ ]
+ elif k == AtomicDataDict.CELL_KEY:
+ new_dict[k] = self[k]
+ elif k == AtomicDataDict.ENV_INDEX_KEY:
+ new_dict[AtomicDataDict.ENV_INDEX_KEY] = new_index[
+ self.env_index[:, env_mask]
+ ]
+ elif k == AtomicDataDict.ENV_CELL_SHIFT_KEY:
+ new_dict[AtomicDataDict.ENV_CELL_SHIFT_KEY] = self.env_cell_shift[
+ env_mask
+ ]
+ elif k == AtomicDataDict.ONSITENV_INDEX_KEY:
+ new_dict[AtomicDataDict.ONSITENV_INDEX_KEY] = new_index[
+ self.onsitenv_index[:, onsitenv_mask]
+ ]
+ elif k == AtomicDataDict.ONSITENV_CELL_SHIFT_KEY:
+ new_dict[AtomicDataDict.ONSITENV_CELL_SHIFT_KEY] = self.onsitenv_cell_shift[
+ onsitenv_mask
+ ]
+ else:
+ if isinstance(self[k], torch.Tensor) and len(self[k]) == self.num_nodes:
+ new_dict[k] = self[k][mask]
+ else:
+ new_dict[k] = self[k]
+
+ new_dict["irreps"] = self.__irreps__
+
+ return type(self)(**new_dict)
+
+
+_ERROR_ON_NO_EDGES: bool = os.environ.get("NEQUIP_ERROR_ON_NO_EDGES", "true").lower()
+assert _ERROR_ON_NO_EDGES in ("true", "false")
+_ERROR_ON_NO_EDGES = _ERROR_ON_NO_EDGES == "true"
+
+
+def neighbor_list_and_relative_vec(
+ pos,
+ r_max,
+ self_interaction=False,
+ reduce=True,
+ atomic_numbers=None,
+ cell=None,
+ pbc=False,
+):
+ """Create neighbor list and neighbor vectors based on radial cutoff.
+
+ Create neighbor list (``edge_index``) and relative vectors
+ (``edge_attr``) based on radial cutoff.
+
+ Edges are given by the following convention:
+ - ``edge_index[0]`` is the *source* (convolution center).
+ - ``edge_index[1]`` is the *target* (neighbor).
+
+ Thus, ``edge_index`` has the same convention as the relative vectors:
+ :math:`\\vec{r}_{source, target}`
+
+ If the input positions are a tensor with ``requires_grad == True``,
+ the output displacement vectors will be correctly attached to the inputs
+ for autograd.
+
+ All outputs are Tensors on the same device as ``pos``; this allows future
+ optimization of the neighbor list on the GPU.
+
+ Args:
+ pos (shape [N, 3]): Positional coordinate; Tensor or numpy array. If Tensor, must be on CPU.
+ r_max (float): Radial cutoff distance for neighbor finding.
+ cell (numpy shape [3, 3]): Cell for periodic boundary conditions. Ignored if ``pbc == False``.
+ pbc (bool or 3-tuple of bool): Whether the system is periodic in each of the three cell dimensions.
+ self_interaction (bool): Whether or not to include same periodic image self-edges in the neighbor list.
+ strict_self_interaction (bool): Whether to include *any* self interaction edges in the graph, even if the two
+ instances of the atom are in different periodic images. Defaults to True, should be True for most applications.
+
+ Returns:
+ edge_index (torch.tensor shape [2, num_edges]): List of edges.
+ edge_cell_shift (torch.tensor shape [num_edges, 3]): Relative cell shift
+ vectors. Returned only if cell is not None.
+ cell (torch.Tensor [3, 3]): the cell as a tensor on the correct device.
+ Returned only if cell is not None.
+ """
+ if isinstance(pbc, bool):
+ pbc = (pbc,) * 3
+
+ # Either the position or the cell may be on the GPU as tensors
+ if isinstance(pos, torch.Tensor):
+ temp_pos = pos.detach().cpu().numpy()
+ out_device = pos.device
+ out_dtype = pos.dtype
+ else:
+ temp_pos = np.asarray(pos)
+ out_device = torch.device("cpu")
+ out_dtype = torch.get_default_dtype()
+
+ # Right now, GPU tensors require a round trip
+ if out_device.type != "cpu":
+ warnings.warn(
+ "Currently, neighborlists require a round trip to the CPU. Please pass CPU tensors if possible."
+ )
+
+ # Get a cell on the CPU no matter what
+ if isinstance(cell, torch.Tensor):
+ temp_cell = cell.detach().cpu().numpy()
+ cell_tensor = cell.to(device=out_device, dtype=out_dtype)
+ elif cell is not None:
+ temp_cell = np.asarray(cell)
+ cell_tensor = torch.as_tensor(temp_cell, device=out_device, dtype=out_dtype)
+ else:
+ # ASE will "complete" this correctly.
+ temp_cell = np.zeros((3, 3), dtype=temp_pos.dtype)
+ cell_tensor = torch.as_tensor(temp_cell, device=out_device, dtype=out_dtype)
+
+ # ASE dependent part
+ temp_cell = ase.geometry.complete_cell(temp_cell)
+
+ first_idex, second_idex, shifts = ase.neighborlist.primitive_neighbor_list(
+ "ijS",
+ pbc,
+ temp_cell,
+ temp_pos,
+ cutoff=float(r_max),
+ self_interaction=self_interaction, # we want edges from atom to itself in different periodic images!
+ use_scaled_positions=False,
+ )
+
+ # Eliminate true self-edges that don't cross periodic boundaries
+ # if not self_interaction:
+ # bad_edge = first_idex == second_idex
+ # bad_edge &= np.all(shifts == 0, axis=1)
+ # keep_edge = ~bad_edge
+ # if _ERROR_ON_NO_EDGES and (not np.any(keep_edge)):
+ # raise ValueError(
+ # f"Every single atom has no neighbors within the cutoff r_max={r_max} (after eliminating self edges, no edges remain in this system)"
+ # )
+ # first_idex = first_idex[keep_edge]
+ # second_idex = second_idex[keep_edge]
+ # shifts = shifts[keep_edge]
+
+ """
+ bond list is: i, j, shift; but i j shift and j i -shift are the same bond. so we need to remove the duplicate bonds.s
+ first for i != j; we only keep i < j; then the j i -shift will be removed.
+ then, for i == j; we only keep i i shift and remove i i -shift.
+ """
+ # 1. for i != j, keep i < j
+ assert atomic_numbers is not None
+ atomic_numbers = torch.as_tensor(atomic_numbers, dtype=torch.long)
+ mask = first_idex <= second_idex
+ first_idex = first_idex[mask]
+ second_idex = second_idex[mask]
+ shifts = shifts[mask]
+
+ # 2. for i == j
+
+ mask = torch.ones(len(first_idex), dtype=torch.bool)
+ mask[first_idex == second_idex] = False
+ # get index bool type ~mask for i == j.
+ o_first_idex = first_idex[~mask]
+ o_second_idex = second_idex[~mask]
+ o_shift = shifts[~mask]
+ o_mask = mask[~mask] # this is all False, with length being the number all the bonds with i == j.
+
+
+ # using the dict key to remove the duplicate bonds, because it is O(1) to check if a key is in the dict.
+ rev_dict = {}
+ for i in range(len(o_first_idex)):
+ key = str(o_first_idex[i])+str(o_shift[i])
+ key_rev = str(o_first_idex[i])+str(-o_shift[i])
+ rev_dict[key] = True
+ # key_rev is the reverse key of key, if key_rev is in the dict, then the bond is duplicate.
+ # so， only when key_rev is not in the dict, we keep the bond. that is when rev_dict.get(key_rev, False) is False, we set o_mast = True.
+ if not (rev_dict.get(key_rev, False) and rev_dict.get(key, False)):
+ o_mask[i] = True
+ del rev_dict
+ del o_first_idex
+ del o_second_idex
+ del o_shift
+ mask[~mask] = o_mask
+ del o_mask
+
+ first_idex = torch.LongTensor(first_idex[mask], device=out_device)
+ second_idex = torch.LongTensor(second_idex[mask], device=out_device)
+ shifts = torch.as_tensor(shifts[mask], dtype=out_dtype, device=out_device)
+
+ if not reduce:
+ first_idex, second_idex = torch.cat((first_idex, second_idex), dim=0), torch.cat((second_idex, first_idex), dim=0)
+ shifts = torch.cat((shifts, -shifts), dim=0)
+
+ # Build output:
+ edge_index = torch.vstack(
+ (torch.LongTensor(first_idex), torch.LongTensor(second_idex))
+ )
+
+ return edge_index, shifts, cell_tensor
diff --git a/dptb/data/AtomicDataDict.py b/dptb/data/AtomicDataDict.py
new file mode 100644
index 00000000..6fc45c9b
--- /dev/null
+++ b/dptb/data/AtomicDataDict.py
@@ -0,0 +1,233 @@
+"""nequip.data.jit: TorchScript functions for dealing with AtomicData.
+
+These TorchScript functions operate on ``Dict[str, torch.Tensor]`` representations
+of the ``AtomicData`` class which are produced by ``AtomicData.to_AtomicDataDict()``.
+
+Authors: Albert Musaelian
+"""
+from typing import Dict, Any
+
+import torch
+import torch.jit
+
+from e3nn import o3
+
+# Make the keys available in this module
+from ._keys import * # noqa: F403, F401
+
+# Also import the module to use in TorchScript, this is a hack to avoid bug:
+# https://github.com/pytorch/pytorch/issues/52312
+from . import _keys
+
+# Define a type alias
+Type = Dict[str, torch.Tensor]
+
+
+def validate_keys(keys, graph_required=True):
+ # Validate combinations
+ if graph_required:
+ if not (_keys.POSITIONS_KEY in keys and _keys.EDGE_INDEX_KEY in keys):
+ raise KeyError("At least pos and edge_index must be supplied")
+ if _keys.EDGE_CELL_SHIFT_KEY in keys and "cell" not in keys:
+ raise ValueError("If `edge_cell_shift` given, `cell` must be given.")
+
+
+_SPECIAL_IRREPS = [None]
+
+
+def _fix_irreps_dict(d: Dict[str, Any]):
+ return {k: (i if i in _SPECIAL_IRREPS else o3.Irreps(i)) for k, i in d.items()}
+
+
+def _irreps_compatible(ir1: Dict[str, o3.Irreps], ir2: Dict[str, o3.Irreps]):
+ return all(ir1[k] == ir2[k] for k in ir1 if k in ir2)
+
+
+@torch.jit.script
+def with_edge_vectors(data: Type, with_lengths: bool = True) -> Type:
+ """Compute the edge displacement vectors for a graph.
+
+ If ``data.pos.requires_grad`` and/or ``data.cell.requires_grad``, this
+ method will return edge vectors correctly connected in the autograd graph.
+
+ Returns:
+ Tensor [n_edges, 3] edge displacement vectors
+ """
+ if _keys.EDGE_VECTORS_KEY in data:
+ if with_lengths and _keys.EDGE_LENGTH_KEY not in data:
+ data[_keys.EDGE_LENGTH_KEY] = torch.linalg.norm(
+ data[_keys.EDGE_VECTORS_KEY], dim=-1
+ )
+
+ return data
+ else:
+ # Build it dynamically
+ # Note that this is
+ # (1) backwardable, because everything (pos, cell, shifts)
+ # is Tensors.
+ # (2) works on a Batch constructed from AtomicData
+ pos = data[_keys.POSITIONS_KEY]
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_vec = pos[edge_index[1]] - pos[edge_index[0]]
+ if _keys.CELL_KEY in data:
+ # ^ note that to save time we don't check that the edge_cell_shifts are trivial if no cell is provided; we just assume they are either not present or all zero.
+ # -1 gives a batch dim no matter what
+ cell = data[_keys.CELL_KEY].view(-1, 3, 3)
+ edge_cell_shift = data[_keys.EDGE_CELL_SHIFT_KEY]
+ if cell.shape[0] > 1:
+ batch = data[_keys.BATCH_KEY]
+ # Cell has a batch dimension
+ # note the ASE cell vectors as rows convention
+ edge_vec = edge_vec + torch.einsum(
+ "ni,nij->nj", edge_cell_shift, cell[batch[edge_index[0]]]
+ )
+ # TODO: is there a more efficient way to do the above without
+ # creating an [n_edge] and [n_edge, 3, 3] tensor?
+ else:
+ # Cell has either no batch dimension, or a useless one,
+ # so we can avoid creating the large intermediate cell tensor.
+ # Note that we do NOT check that the batch array, if it is present,
+ # is trivial — but this does need to be consistent.
+ edge_vec = edge_vec + torch.einsum(
+ "ni,ij->nj",
+ edge_cell_shift,
+ cell.squeeze(0), # remove batch dimension
+ )
+
+ data[_keys.EDGE_VECTORS_KEY] = edge_vec
+ if with_lengths:
+ data[_keys.EDGE_LENGTH_KEY] = torch.linalg.norm(edge_vec, dim=-1)
+ return data
+
+@torch.jit.script
+def with_env_vectors(data: Type, with_lengths: bool = True) -> Type:
+ """Compute the edge displacement vectors for a graph.
+
+ If ``data.pos.requires_grad`` and/or ``data.cell.requires_grad``, this
+ method will return edge vectors correctly connected in the autograd graph.
+
+ Returns:
+ Tensor [n_edges, 3] edge displacement vectors
+ """
+ if _keys.ENV_VECTORS_KEY in data:
+ if with_lengths and _keys.ENV_LENGTH_KEY not in data:
+ data[_keys.ENV_LENGTH_KEY] = torch.linalg.norm(
+ data[_keys.ENV_VECTORS_KEY], dim=-1
+ )
+ return data
+ else:
+ # Build it dynamically
+ # Note that this is
+ # (1) backwardable, because everything (pos, cell, shifts)
+ # is Tensors.
+ # (2) works on a Batch constructed from AtomicData
+ pos = data[_keys.POSITIONS_KEY]
+ env_index = data[_keys.ENV_INDEX_KEY]
+ env_vec = pos[env_index[1]] - pos[env_index[0]]
+ if _keys.CELL_KEY in data:
+ # ^ note that to save time we don't check that the edge_cell_shifts are trivial if no cell is provided; we just assume they are either not present or all zero.
+ # -1 gives a batch dim no matter what
+ cell = data[_keys.CELL_KEY].view(-1, 3, 3)
+ env_cell_shift = data[_keys.ENV_CELL_SHIFT_KEY]
+ if cell.shape[0] > 1:
+ batch = data[_keys.BATCH_KEY]
+ # Cell has a batch dimension
+ # note the ASE cell vectors as rows convention
+ env_vec = env_vec + torch.einsum(
+ "ni,nij->nj", env_cell_shift, cell[batch[env_index[0]]]
+ )
+ # TODO: is there a more efficient way to do the above without
+ # creating an [n_edge] and [n_edge, 3, 3] tensor?
+ else:
+ # Cell has either no batch dimension, or a useless one,
+ # so we can avoid creating the large intermediate cell tensor.
+ # Note that we do NOT check that the batch array, if it is present,
+ # is trivial — but this does need to be consistent.
+ env_vec = env_vec + torch.einsum(
+ "ni,ij->nj",
+ env_cell_shift,
+ cell.squeeze(0), # remove batch dimension
+ )
+ data[_keys.ENV_VECTORS_KEY] = env_vec
+ if with_lengths:
+ data[_keys.ENV_LENGTH_KEY] = torch.linalg.norm(env_vec, dim=-1)
+ return data
+
+@torch.jit.script
+def with_onsitenv_vectors(data: Type, with_lengths: bool = True) -> Type:
+ """Compute the edge displacement vectors for a graph.
+
+ If ``data.pos.requires_grad`` and/or ``data.cell.requires_grad``, this
+ method will return edge vectors correctly connected in the autograd graph.
+
+ Returns:
+ Tensor [n_edges, 3] edge displacement vectors
+ """
+ if _keys.ONSITENV_VECTORS_KEY in data:
+ if with_lengths and _keys.ONSITENV_LENGTH_KEY not in data:
+ data[_keys.ONSITENV_LENGTH_KEY] = torch.linalg.norm(
+ data[_keys.ONSITENV_VECTORS_KEY], dim=-1
+ )
+ return data
+ else:
+ # Build it dynamically
+ # Note that this is
+ # (1) backwardable, because everything (pos, cell, shifts)
+ # is Tensors.
+ # (2) works on a Batch constructed from AtomicData
+ pos = data[_keys.POSITIONS_KEY]
+ env_index = data[_keys.ONSITENV_INDEX_KEY]
+ env_vec = pos[env_index[1]] - pos[env_index[0]]
+ if _keys.CELL_KEY in data:
+ # ^ note that to save time we don't check that the edge_cell_shifts are trivial if no cell is provided; we just assume they are either not present or all zero.
+ # -1 gives a batch dim no matter what
+ cell = data[_keys.CELL_KEY].view(-1, 3, 3)
+ env_cell_shift = data[_keys.ONSITENV_CELL_SHIFT_KEY]
+ if cell.shape[0] > 1:
+ batch = data[_keys.BATCH_KEY]
+ # Cell has a batch dimension
+ # note the ASE cell vectors as rows convention
+ env_vec = env_vec + torch.einsum(
+ "ni,nij->nj", env_cell_shift, cell[batch[env_index[0]]]
+ )
+ # TODO: is there a more efficient way to do the above without
+ # creating an [n_edge] and [n_edge, 3, 3] tensor?
+ else:
+ # Cell has either no batch dimension, or a useless one,
+ # so we can avoid creating the large intermediate cell tensor.
+ # Note that we do NOT check that the batch array, if it is present,
+ # is trivial — but this does need to be consistent.
+ env_vec = env_vec + torch.einsum(
+ "ni,ij->nj",
+ env_cell_shift,
+ cell.squeeze(0), # remove batch dimension
+ )
+ data[_keys.ONSITENV_VECTORS_KEY] = env_vec
+ if with_lengths:
+ data[_keys.ONSITENV_LENGTH_KEY] = torch.linalg.norm(env_vec, dim=-1)
+ return data
+
+
+@torch.jit.script
+def with_batch(data: Type) -> Type:
+ """Get batch Tensor.
+
+ If this AtomicDataPrimitive has no ``batch``, one of all zeros will be
+ allocated and returned.
+ """
+ if _keys.BATCH_KEY in data:
+ return data
+ else:
+ pos = data[_keys.POSITIONS_KEY]
+ batch = torch.zeros(len(pos), dtype=torch.long, device=pos.device)
+ data[_keys.BATCH_KEY] = batch
+ # ugly way to make a tensor of [0, len(pos)], but it avoids transfers or casts
+ data[_keys.BATCH_PTR_KEY] = torch.arange(
+ start=0,
+ end=len(pos) + 1,
+ step=len(pos),
+ dtype=torch.long,
+ device=pos.device,
+ )
+
+ return data
diff --git a/dptb/data/__init__.py b/dptb/data/__init__.py
new file mode 100644
index 00000000..2efca699
--- /dev/null
+++ b/dptb/data/__init__.py
@@ -0,0 +1,49 @@
+from .AtomicData import (
+ AtomicData,
+ PBC,
+ register_fields,
+ deregister_fields,
+ _register_field_prefix,
+ _NODE_FIELDS,
+ _EDGE_FIELDS,
+ _GRAPH_FIELDS,
+ _LONG_FIELDS,
+)
+from .dataset import (
+ AtomicDataset,
+ AtomicInMemoryDataset,
+ NpzDataset,
+ ASEDataset,
+ HDF5Dataset,
+ ABACUSDataset,
+ ABACUSInMemoryDataset,
+ DefaultDataset
+)
+from .dataloader import DataLoader, Collater, PartialSampler
+from .build import dataset_from_config
+from .test_data import EMTTestDataset
+
+__all__ = [
+ AtomicData,
+ PBC,
+ register_fields,
+ deregister_fields,
+ _register_field_prefix,
+ AtomicDataset,
+ AtomicInMemoryDataset,
+ NpzDataset,
+ ASEDataset,
+ HDF5Dataset,
+ ABACUSDataset,
+ ABACUSInMemoryDataset,
+ DefaultDataset,
+ DataLoader,
+ Collater,
+ PartialSampler,
+ dataset_from_config,
+ _NODE_FIELDS,
+ _EDGE_FIELDS,
+ _GRAPH_FIELDS,
+ _LONG_FIELDS,
+ EMTTestDataset,
+]
diff --git a/dptb/data/_keys.py b/dptb/data/_keys.py
new file mode 100644
index 00000000..187d4c79
--- /dev/null
+++ b/dptb/data/_keys.py
@@ -0,0 +1,125 @@
+"""Keys for dictionaries/AtomicData objects.
+
+This is a seperate module to compensate for a TorchScript bug that can only recognize constants when they are accessed as attributes of an imported module.
+"""
+
+import sys
+from typing import List
+
+if sys.version_info[1] >= 8:
+ from typing import Final
+else:
+ from typing_extensions import Final
+
+# == Define allowed keys as constants ==
+# The positions of the atoms in the system
+POSITIONS_KEY: Final[str] = "pos"
+# The [2, n_edge] index tensor giving center -> neighbor relations
+EDGE_INDEX_KEY: Final[str] = "edge_index"
+# The [2, n_env] index tensor giving center -> neighbor relations
+ENV_INDEX_KEY: Final[str] = "env_index"
+# The [2, n_onsitenv] index tensor giving center -> neighbor relations
+ONSITENV_INDEX_KEY: Final[str] = "onsitenv_index"
+# A [n_edge, 3] tensor of how many periodic cells each env crosses in each cell vector
+ENV_CELL_SHIFT_KEY: Final[str] = "env_cell_shift"
+# A [n_edge, 3] tensor of how many periodic cells each edge crosses in each cell vector
+EDGE_CELL_SHIFT_KEY: Final[str] = "edge_cell_shift"
+# [n_batch, 3, 3] or [3, 3] tensor where rows are the cell vectors
+ONSITENV_CELL_SHIFT_KEY: Final[str] = "onsitenv_cell_shift"
+# [n_batch, 3, 3] or [3, 3] tensor where rows are the cell vectors
+CELL_KEY: Final[str] = "cell"
+# [n_kpoints, 3] or [n_batch, nkpoints, 3] tensor
+KPOINT_KEY = "kpoint"
+
+HAMILTONIAN_KEY = "hamiltonian"
+
+OVERLAP_KEY = "overlap"
+# [n_batch, 3] bool tensor
+PBC_KEY: Final[str] = "pbc"
+# [n_atom, 1] long tensor
+ATOMIC_NUMBERS_KEY: Final[str] = "atomic_numbers"
+# [n_atom, 1] long tensor
+ATOM_TYPE_KEY: Final[str] = "atom_types"
+# [n_batch, n_kpoint, n_orb]
+ENERGY_EIGENVALUE_KEY: Final[str] = "eigenvalue"
+
+# [n_batch, 2]
+ENERGY_WINDOWS_KEY = "ewindow"
+BAND_WINDOW_KEY = "bwindow"
+
+BASIC_STRUCTURE_KEYS: Final[List[str]] = [
+ POSITIONS_KEY,
+ EDGE_INDEX_KEY,
+ EDGE_CELL_SHIFT_KEY,
+ CELL_KEY,
+ PBC_KEY,
+ ATOM_TYPE_KEY,
+ ATOMIC_NUMBERS_KEY,
+]
+
+# A [n_edge, 3] tensor of displacement vectors associated to edges
+EDGE_VECTORS_KEY: Final[str] = "edge_vectors"
+# A [n_edge, 3] tensor of displacement vectors associated to envs
+ENV_VECTORS_KEY: Final[str] = "env_vectors"
+# A [n_edge, 3] tensor of displacement vectors associated to onsitenvs
+ONSITENV_VECTORS_KEY: Final[str] = "onsitenv_vectors"
+# A [n_edge] tensor of the lengths of EDGE_VECTORS
+EDGE_LENGTH_KEY: Final[str] = "edge_lengths"
+# A [n_edge] tensor of the lengths of ENV_VECTORS
+ENV_LENGTH_KEY: Final[str] = "env_lengths"
+# A [n_edge] tensor of the lengths of ONSITENV_VECTORS
+ONSITENV_LENGTH_KEY: Final[str] = "onsitenv_lengths"
+# [n_edge, dim] (possibly equivariant) attributes of each edge
+EDGE_ATTRS_KEY: Final[str] = "edge_attrs"
+ENV_ATTRS_KEY: Final[str] = "env_attrs"
+ONSITENV_ATTRS_KEY: Final[str] = "onsitenv_attrs"
+# [n_edge, dim] invariant embedding of the edges
+EDGE_EMBEDDING_KEY: Final[str] = "edge_embedding"
+ENV_EMBEDDING_KEY: Final[str] = "env_embedding"
+ONSITENV_EMBEDDING_KEY: Final[str] = "onsitenv_embedding"
+EDGE_FEATURES_KEY: Final[str] = "edge_features"
+ENV_FEATURES_KEY: Final[str] = "env_features"
+ONSITENV_FEATURES_KEY: Final[str] = "onsitenv_features"
+# [n_edge, 1] invariant of the radial cutoff envelope for each edge, allows reuse of cutoff envelopes
+EDGE_CUTOFF_KEY: Final[str] = "edge_cutoff"
+# [n_edge, 1] invariant of the radial cutoff envelope for each env edge, allows reuse of cutoff envelopes
+ENV_CUTOFF_KEY: Final[str] = "env_cutoff"
+# [n_edge, 1] invariant of the radial cutoff envelope for each onsitenv edge, allows reuse of cutoff envelopes
+ONSITENV_CUTOFF_KEY: Final[str] = "onsitenv_cutoff"
+# edge energy as in Allegro
+EDGE_ENERGY_KEY: Final[str] = "edge_energy"
+EDGE_OVERLAP_KEY: Final[str] = "edge_overlap"
+NODE_OVERLAP_KEY: Final[str] = "node_overlap"
+EDGE_HAMILTONIAN_KEY: Final[str] = "edge_hamiltonian"
+NODE_HAMILTONIAN_KEY: Final[str] = "node_hamiltonian"
+
+NODE_FEATURES_KEY: Final[str] = "node_features"
+NODE_ATTRS_KEY: Final[str] = "node_attrs"
+EDGE_TYPE_KEY: Final[str] = "edge_type"
+
+PER_ATOM_ENERGY_KEY: Final[str] = "atomic_energy"
+TOTAL_ENERGY_KEY: Final[str] = "total_energy"
+FORCE_KEY: Final[str] = "forces"
+PARTIAL_FORCE_KEY: Final[str] = "partial_forces"
+STRESS_KEY: Final[str] = "stress"
+VIRIAL_KEY: Final[str] = "virial"
+
+ALL_ENERGY_KEYS: Final[List[str]] = [
+ EDGE_ENERGY_KEY,
+ PER_ATOM_ENERGY_KEY,
+ TOTAL_ENERGY_KEY,
+ FORCE_KEY,
+ PARTIAL_FORCE_KEY,
+ STRESS_KEY,
+ VIRIAL_KEY,
+]
+
+BATCH_KEY: Final[str] = "batch"
+BATCH_PTR_KEY: Final[str] = "ptr"
+
+# Make a list of allowed keys
+ALLOWED_KEYS: List[str] = [
+ getattr(sys.modules[__name__], k)
+ for k in sys.modules[__name__].__dict__.keys()
+ if k.endswith("_KEY")
+]
diff --git a/dptb/data/build.py b/dptb/data/build.py
new file mode 100644
index 00000000..f419c15f
--- /dev/null
+++ b/dptb/data/build.py
@@ -0,0 +1,191 @@
+import inspect
+import os
+from copy import deepcopy
+import glob
+from importlib import import_module
+
+from dptb.data.dataset import DefaultDataset
+from dptb import data
+from dptb.data.transforms import TypeMapper, OrbitalMapper
+from dptb.data import AtomicDataset, register_fields
+from dptb.utils import instantiate, get_w_prefix
+from dptb.utils.tools import j_loader
+from dptb.utils.argcheck import normalize_setinfo
+
+
+def dataset_from_config(config, prefix: str = "dataset") -> AtomicDataset:
+ """initialize database based on a config instance
+
+ It needs dataset type name (case insensitive),
+ and all the parameters needed in the constructor.
+
+ Examples see tests/data/test_dataset.py TestFromConfig
+ and tests/datasets/test_simplest.py
+
+ Args:
+
+ config (dict, nequip.utils.Config): dict/object that store all the parameters
+ prefix (str): Optional. The prefix of all dataset parameters
+
+ Return:
+
+ dataset (nequip.data.AtomicDataset)
+ """
+
+ config_dataset = config.get(prefix, None)
+ if config_dataset is None:
+ raise KeyError(f"Dataset with prefix `{prefix}` isn't present in this config!")
+
+ if inspect.isclass(config_dataset):
+ # user define class
+ class_name = config_dataset
+ else:
+ try:
+ module_name = ".".join(config_dataset.split(".")[:-1])
+ class_name = ".".join(config_dataset.split(".")[-1:])
+ class_name = getattr(import_module(module_name), class_name)
+ except Exception:
+ # ^ TODO: don't catch all Exception
+ # default class defined in nequip.data or nequip.dataset
+ dataset_name = config_dataset.lower()
+
+ class_name = None
+ for k, v in inspect.getmembers(data, inspect.isclass):
+ if k.endswith("Dataset"):
+ if k.lower() == dataset_name:
+ class_name = v
+ if k[:-7].lower() == dataset_name:
+ class_name = v
+ elif k.lower() == dataset_name:
+ class_name = v
+
+ if class_name is None:
+ raise NameError(f"dataset type {dataset_name} does not exists")
+
+ # if dataset r_max is not found, use the universal r_max
+ atomicdata_options_key = "AtomicData_options"
+ prefixed_eff_key = f"{prefix}_{atomicdata_options_key}"
+ config[prefixed_eff_key] = get_w_prefix(
+ atomicdata_options_key, {}, prefix=prefix, arg_dicts=config
+ )
+ config[prefixed_eff_key]["r_max"] = get_w_prefix(
+ "r_max",
+ prefix=prefix,
+ arg_dicts=[config[prefixed_eff_key], config],
+ )
+
+ config[prefixed_eff_key]["er_max"] = get_w_prefix(
+ "er_max",
+ prefix=prefix,
+ arg_dicts=[config[prefixed_eff_key], config],
+ )
+
+ config[prefixed_eff_key]["oer_max"] = get_w_prefix(
+ "oer_max",
+ prefix=prefix,
+ arg_dicts=[config[prefixed_eff_key], config],
+ )
+
+ # Build a TypeMapper from the config
+ type_mapper, _ = instantiate(TypeMapper, prefix=prefix, optional_args=config)
+
+ # Register fields:
+ # This might reregister fields, but that's OK:
+ instantiate(register_fields, all_args=config)
+
+ instance, _ = instantiate(
+ class_name,
+ prefix=prefix,
+ positional_args={"type_mapper": type_mapper},
+ optional_args=config,
+ )
+
+ return instance
+
+
+def build_dataset(set_options, common_options):
+
+ dataset_type = set_options.get("type", "DefaultDataset")
+
+ # input in set_option for Default Dataset:
+ # "root": main dir storing all trajectory folders.
+ # that is, each subfolder of root contains a trajectory.
+ # "prefix": optional, load selected trajectory folders.
+ # "get_Hamiltonian": load the Hamiltonian file to edges of the graph or not.
+ # "get_eigenvalues": load the eigenvalues to the graph or not.
+ # "setinfo": MUST HAVE, the name of the json file used to build dataset.
+ # Example:
+ # "train": {
+ # "type": "DefaultDataset",
+ # "root": "foo/bar/data_files_here",
+ # "prefix": "traj",
+ # "setinfo": "with_pbc.json"
+ # }
+ if dataset_type == "DefaultDataset":
+ # See if we can get a OrbitalMapper.
+ if "basis" in common_options:
+ idp = OrbitalMapper(common_options["basis"])
+ else:
+ idp = None
+
+ # Explore the dataset's folder structure.
+ root = set_options["root"]
+ prefix = set_options.get("prefix", None)
+ include_folders = []
+ for dir_name in os.listdir(root):
+ dir_path = os.path.join(root, dir_name)
+ if os.path.isdir(dir_path):
+ # If the `processed_dataset` or other folder is here too, they do not have the proper traj data files.
+ # And we will have problem in generating TrajData!
+ # So we test it here: the data folder must have `.dat` or `.traj` file.
+ if glob.glob(os.path.join(dir_path, '*.dat')) or glob.glob(os.path.join(dir_path, '*.traj')):
+ if prefix is not None:
+ if dir_name[:len(prefix)] == prefix:
+ include_folders.append(dir_name)
+ else:
+ include_folders.append(dir_name)
+
+ # We need to check the `setinfo.json` very carefully here.
+ # Different `setinfo` points to different dataset,
+ # even if the data files in `root` are basically the same.
+ info_files = {}
+
+ # See if a public info is provided.
+ if "info.json" in os.listdir(root):
+ public_info = j_loader(os.path.join(root, "info.json"))
+ public_info = normalize_setinfo(public_info)
+ print("A public `info.json` file is provided, and will be used by the subfolders who do not have their own `info.json` file.")
+ else:
+ public_info = None
+
+ # Load info in each trajectory folders seperately.
+ for file in include_folders:
+ if "info.json" in os.listdir(os.path.join(root, file)):
+ # use info provided in this trajectory.
+ info = j_loader(os.path.join(root, file, "info.json"))
+ info = normalize_setinfo(info)
+ info_files[file] = info
+ elif public_info is not None:
+ # use public info instead
+ # yaml will not dump correctly if this is not a deepcopy.
+ info_files[file] = deepcopy(public_info)
+ else:
+ # no info for this file
+ raise Exception(f"info.json is not properly provided for `{file}`.")
+
+ # We will sort the info_files here.
+ # The order itself is not important, but must be consistant for the same list.
+ info_files = {key: info_files[key] for key in sorted(info_files)}
+
+ dataset = DefaultDataset(
+ root=root,
+ type_mapper=idp,
+ get_Hamiltonian=set_options.get("get_Hamiltonian", False),
+ get_eigenvalues=set_options.get("get_eigenvalues", False),
+ info_files = info_files
+ )
+
+ else:
+ raise ValueError(f"Not support dataset type: {type}.")
+
+ return dataset
diff --git a/dptb/data/dataloader.py b/dptb/data/dataloader.py
new file mode 100644
index 00000000..1f383f1a
--- /dev/null
+++ b/dptb/data/dataloader.py
@@ -0,0 +1,163 @@
+from typing import List, Optional, Iterator
+
+import torch
+from torch.utils.data import Sampler
+
+from dptb.utils.torch_geometric import Batch, Data, Dataset
+
+class Collater(object):
+ """Collate a list of ``AtomicData``.
+
+ Args:
+ exclude_keys: keys to ignore in the input, not copying to the output
+ """
+
+ def __init__(
+ self,
+ exclude_keys: List[str] = [],
+ ):
+ self._exclude_keys = set(exclude_keys)
+
+ @classmethod
+ def for_dataset(
+ cls,
+ dataset,
+ exclude_keys: List[str] = [],
+ ):
+ """Construct a collater appropriate to ``dataset``."""
+ return cls(
+ exclude_keys=exclude_keys,
+ )
+
+ def collate(self, batch: List[Data]) -> Batch:
+ """Collate a list of data"""
+ out = Batch.from_data_list(batch, exclude_keys=self._exclude_keys)
+ return out
+
+ def __call__(self, batch: List[Data]) -> Batch:
+ """Collate a list of data"""
+ return self.collate(batch)
+
+ @property
+ def exclude_keys(self):
+ return list(self._exclude_keys)
+
+
+class DataLoader(torch.utils.data.DataLoader):
+ def __init__(
+ self,
+ dataset,
+ batch_size: int = 1,
+ shuffle: bool = False,
+ exclude_keys: List[str] = [],
+ **kwargs,
+ ):
+ if "collate_fn" in kwargs:
+ del kwargs["collate_fn"]
+
+ super(DataLoader, self).__init__(
+ dataset,
+ batch_size,
+ shuffle,
+ collate_fn=Collater.for_dataset(dataset, exclude_keys=exclude_keys),
+ **kwargs,
+ )
+
+
+class PartialSampler(Sampler[int]):
+ r"""Samples elements without replacement, but divided across a number of calls to `__iter__`.
+
+ To ensure deterministic reproducibility and restartability, dataset permutations are generated
+ from a combination of the overall seed and the epoch number. As a result, the caller must
+ tell this sampler the epoch number before each time `__iter__` is called by calling
+ `my_partial_sampler.step_epoch(epoch_number_about_to_run)` each time.
+
+ This sampler decouples epochs from the dataset size and cycles through the dataset over as
+ many (partial) epochs as it may take. As a result, the _dataset_ epoch can change partway
+ through a training epoch.
+
+ Args:
+ data_source (Dataset): dataset to sample from
+ shuffle (bool): whether to shuffle the dataset each time the _entire_ dataset is consumed
+ num_samples_per_epoch (int): number of samples to draw in each call to `__iter__`.
+ If `None`, defaults to `len(data_source)`.
+ generator (Generator): Generator used in sampling.
+ """
+ data_source: Dataset
+ num_samples_per_epoch: int
+ shuffle: bool
+ _epoch: int
+ _prev_epoch: int
+
+ def __init__(
+ self,
+ data_source: Dataset,
+ shuffle: bool = True,
+ num_samples_per_epoch: Optional[int] = None,
+ generator=None,
+ ) -> None:
+ self.data_source = data_source
+ self.shuffle = shuffle
+ if num_samples_per_epoch is None:
+ num_samples_per_epoch = self.num_samples_total
+ self.num_samples_per_epoch = num_samples_per_epoch
+ assert self.num_samples_per_epoch <= self.num_samples_total
+ assert self.num_samples_per_epoch >= 1
+ self.generator = generator
+ self._epoch = None
+ self._prev_epoch = None
+
+ @property
+ def num_samples_total(self) -> int:
+ # dataset size might change at runtime
+ return len(self.data_source)
+
+ def step_epoch(self, epoch: int) -> None:
+ self._epoch = epoch
+
+ def __iter__(self) -> Iterator[int]:
+ assert self._epoch is not None
+ assert (self._prev_epoch is None) or (self._epoch == self._prev_epoch + 1)
+ assert self._epoch >= 0
+
+ full_epoch_i, start_sample_i = divmod(
+ # how much data we've already consumed:
+ self._epoch * self.num_samples_per_epoch,
+ # how much data there is the dataset:
+ self.num_samples_total,
+ )
+
+ if self.shuffle:
+ temp_rng = torch.Generator()
+ # Get new randomness for each _full_ time through the dataset
+ # This is deterministic w.r.t. the combination of dataset seed and epoch number
+ # Both of which persist across restarts
+ # (initial_seed() is restored by set_state())
+ temp_rng.manual_seed(self.generator.initial_seed() + full_epoch_i)
+ full_order_this = torch.randperm(self.num_samples_total, generator=temp_rng)
+ # reseed the generator for the _next_ epoch to get the shuffled order of the
+ # _next_ dataset epoch to pad out this one for completing any partial batches
+ # at the end:
+ temp_rng.manual_seed(self.generator.initial_seed() + full_epoch_i + 1)
+ full_order_next = torch.randperm(self.num_samples_total, generator=temp_rng)
+ del temp_rng
+ else:
+ full_order_this = torch.arange(self.num_samples_total)
+ # without shuffling, the next epoch has the same sampling order as this one:
+ full_order_next = full_order_this
+
+ full_order = torch.cat((full_order_this, full_order_next), dim=0)
+ del full_order_next, full_order_this
+
+ this_segment_indexes = full_order[
+ start_sample_i : start_sample_i + self.num_samples_per_epoch
+ ]
+ # because we cycle into indexes from the next dataset epoch,
+ # we should _always_ be able to get num_samples_per_epoch
+ assert len(this_segment_indexes) == self.num_samples_per_epoch
+ yield from this_segment_indexes
+
+ self._prev_epoch = self._epoch
+
+ def __len__(self) -> int:
+ return self.num_samples_per_epoch
diff --git a/dptb/data/dataset/__init__.py b/dptb/data/dataset/__init__.py
new file mode 100644
index 00000000..c8dca670
--- /dev/null
+++ b/dptb/data/dataset/__init__.py
@@ -0,0 +1,21 @@
+from ._base_datasets import AtomicDataset, AtomicInMemoryDataset
+from ._ase_dataset import ASEDataset
+from ._npz_dataset import NpzDataset
+from ._hdf5_dataset import HDF5Dataset
+from ._abacus_dataset import ABACUSDataset, ABACUSInMemoryDataset
+from ._deeph_dataset import DeePHE3Dataset
+from ._default_dataset import DefaultDataset
+
+
+__all__ = [
+ DefaultDataset,
+ DeePHE3Dataset,
+ ABACUSInMemoryDataset,
+ ABACUSDataset,
+ ASEDataset,
+ AtomicDataset,
+ AtomicInMemoryDataset,
+ NpzDataset,
+ HDF5Dataset
+ ]
+
diff --git a/dptb/data/dataset/_abacus_dataset.py b/dptb/data/dataset/_abacus_dataset.py
new file mode 100644
index 00000000..bcdb1c62
--- /dev/null
+++ b/dptb/data/dataset/_abacus_dataset.py
@@ -0,0 +1,109 @@
+from typing import Dict, Any, List, Callable, Union, Optional
+import os
+
+import numpy as np
+import h5py
+
+import torch
+
+from .. import (
+ AtomicData,
+ AtomicDataDict,
+)
+
+from ..transforms import TypeMapper, OrbitalMapper
+from ._base_datasets import AtomicDataset, AtomicInMemoryDataset
+#from dptb.nn.hamiltonian import E3Hamiltonian
+from dptb.data.interfaces.ham_to_feature import ham_block_to_feature
+
+orbitalLId = {0:"s", 1:"p", 2:"d", 3:"f"}
+
+def _abacus_h5_reader(h5file_path, AtomicData_options):
+ data = h5py.File(h5file_path, "r")
+ atomic_data = AtomicData.from_points(
+ pos = data["pos"][:],
+ cell = data["cell"][:],
+ atomic_numbers = data["atomic_numbers"][:],
+ **AtomicData_options,
+ )
+ if "hamiltonian_blocks" in data:
+ basis = {}
+ for key, value in data["basis"].items():
+ basis[key] = [(f"{i+1}" + orbitalLId[l]) for i, l in enumerate(value)]
+ idp = OrbitalMapper(basis)
+ # e3 = E3Hamiltonian(idp=idp, decompose=True)
+ ham_block_to_feature(atomic_data, idp, data.get("hamiltonian_blocks", False), data.get("overlap_blocks", False))
+ # with torch.no_grad():
+ # atomic_data = e3(atomic_data.to_dict())
+ # atomic_data = AtomicData.from_dict(atomic_data)
+
+ if "eigenvalues" in data and "kpionts" in data:
+ atomic_data[AtomicDataDict.KPOINT_KEY] = torch.as_tensor(data["kpoints"][:], dtype=torch.get_default_dtype())
+ atomic_data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] = torch.as_tensor(data["eigenvalues"][:], dtype=torch.get_default_dtype())
+ return atomic_data
+
+# Lazy loading class, built for large dataset.
+
+class ABACUSDataset(AtomicDataset):
+
+ def __init__(
+ self,
+ root: str,
+ preprocess_dir: str,
+ AtomicData_options: Dict[str, Any] = {},
+ type_mapper: Optional[TypeMapper] = None,
+ ):
+ super().__init__(root=root, type_mapper=type_mapper)
+ self.preprocess_dir = preprocess_dir
+ self.file_name = np.loadtxt(os.path.join(self.preprocess_dir, 'AtomicData_file.txt'), dtype=str)
+ self.AtomicData_options = AtomicData_options
+ self.num_examples = len(self.file_name)
+
+ def get(self, idx):
+ name = self.file_name[idx]
+ h5_file = os.path.join(self.preprocess_dir, name)
+ atomic_data = _abacus_h5_reader(h5_file, self.AtomicData_options)
+ return atomic_data
+
+ def len(self) -> int:
+ return self.num_examples
+
+# In memory version.
+
+class ABACUSInMemoryDataset(AtomicInMemoryDataset):
+
+ def __init__(
+ self,
+ root: str,
+ preprocess_dir: str,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: TypeMapper = None,
+ ):
+ self.preprocess_dir = preprocess_dir
+ self.file_name = np.loadtxt(os.path.join(self.preprocess_dir, 'AtomicData_file.txt'), dtype=str)
+
+ super(ABACUSInMemoryDataset, self).__init__(
+ file_name=self.file_name,
+ url=url,
+ root=root,
+ AtomicData_options=AtomicData_options,
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ def get_data(self):
+ data = []
+ for name in self.file_name:
+ h5_file = os.path.join(self.preprocess_dir, name)
+ data.append(_abacus_h5_reader(h5_file, self.AtomicData_options))
+ return data
+
+ @property
+ def raw_file_names(self):
+ return "AtomicData.h5"
+
+ @property
+ def raw_dir(self):
+ return self.root
\ No newline at end of file
diff --git a/dptb/data/dataset/_abacus_dataset_mem.py b/dptb/data/dataset/_abacus_dataset_mem.py
new file mode 100644
index 00000000..de4263ae
--- /dev/null
+++ b/dptb/data/dataset/_abacus_dataset_mem.py
@@ -0,0 +1,109 @@
+from typing import Dict, Any, List, Callable, Union, Optional
+import os
+
+import numpy as np
+import h5py
+
+import torch
+
+from .. import (
+ AtomicData,
+ AtomicDataDict,
+)
+from ..transforms import TypeMapper, OrbitalMapper
+from ._base_datasets import AtomicInMemoryDataset
+from dptb.nn.hamiltonian import E3Hamiltonian
+from dptb.data.interfaces.ham_to_feature import ham_block_to_feature
+from dptb.data.interfaces.abacus import recursive_parse
+
+orbitalLId = {0:"s", 1:"p", 2:"d", 3:"f"}
+
+def _abacus_h5_reader(h5file_path, AtomicData_options):
+ data = h5py.File(h5file_path, "r")
+ atomic_data = AtomicData.from_points(
+ pos = data["pos"][:],
+ cell = data["cell"][:],
+ atomic_numbers = data["atomic_numbers"][:],
+ **AtomicData_options,
+ )
+ if data["hamiltonian_blocks"]:
+ basis = {}
+ for key, value in data["basis"].items():
+ basis[key] = [(f"{i+1}" + orbitalLId[l]) for i, l in enumerate(value)]
+ idp = OrbitalMapper(basis)
+ # e3 = E3Hamiltonian(idp=idp, decompose=True)
+ ham_block_to_feature(atomic_data, idp, data.get("hamiltonian_blocks", False), data.get("overlap_blocks", False))
+ # with torch.no_grad():
+ # atomic_data = e3(atomic_data.to_dict())
+ # atomic_data = AtomicData.from_dict(atomic_data)
+
+ if data.get("eigenvalue") and data.get("kpoint"):
+ atomic_data[AtomicDataDict.KPOINT_KEY] = torch.as_tensor(data["kpoint"][:], dtype=torch.get_default_dtype())
+ atomic_data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] = torch.as_tensor(data["eigenvalue"][:], dtype=torch.get_default_dtype())
+ return atomic_data
+
+
+class ABACUSInMemoryDataset(AtomicInMemoryDataset):
+
+ def __init__(
+ self,
+ root: str,
+ abacus_args: Dict[str, Union[str,bool]] = {
+ "input_dir": None,
+ "preprocess_dir": None,
+ "only_overlap": False,
+ "get_Ham": False,
+ "add_overlap": False,
+ "get_eigenvalues": False,
+ },
+ file_name: Optional[str] = None,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: TypeMapper = None,
+ key_mapping: Dict[str, str] = {
+ "pos": AtomicDataDict.POSITIONS_KEY,
+ "energy": AtomicDataDict.TOTAL_ENERGY_KEY,
+ "atomic_numbers": AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ "kpoints": AtomicDataDict.KPOINT_KEY,
+ "eigenvalues": AtomicDataDict.ENERGY_EIGENVALUE_KEY,
+ },
+ ):
+ if file_name is not None:
+ self.file_name = file_name
+ else:
+ self.abacus_args = abacus_args
+ assert self.abacus_args.get("input_dir") is not None, "ABACUS calculation results MUST be provided."
+ if self.abacus_args.get("preprocess_dir") is None:
+ print("Creating new preprocess dictionary...")
+ os.mkdir(os.path.join(root, "preprocess"))
+ self.abacus_args["preprocess_dir"] = os.path.join(root, "preprocess")
+ self.key_mapping = key_mapping
+
+ print("Begin parsing ABACUS output...")
+ h5_filenames = recursive_parse(**self.abacus_args)
+ self.file_name = h5_filenames
+ print("Finished parsing ABACUS output.")
+
+ super(ABACUSInMemoryDataset, self).__init__(
+ file_name=self.file_name,
+ url=url,
+ root=root,
+ AtomicData_options=AtomicData_options,
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ def get_data(self):
+ data = []
+ for h5_file in self.file_name:
+ data.append(_abacus_h5_reader(h5_file, self.AtomicData_options))
+ return data
+
+ @property
+ def raw_file_names(self):
+ return "AtomicData.h5"
+
+ @property
+ def raw_dir(self):
+ return self.root
\ No newline at end of file
diff --git a/dptb/data/dataset/_ase_dataset.py b/dptb/data/dataset/_ase_dataset.py
new file mode 100644
index 00000000..6200ebe5
--- /dev/null
+++ b/dptb/data/dataset/_ase_dataset.py
@@ -0,0 +1,238 @@
+import tempfile
+import functools
+import itertools
+from os.path import dirname, basename, abspath
+from typing import Dict, Any, List, Union, Optional, Sequence
+
+import ase
+import ase.io
+
+import torch
+import torch.multiprocessing as mp
+
+
+from dptb.utils.multiprocessing import num_tasks
+from .. import AtomicData
+from ..transforms import TypeMapper
+from ._base_datasets import AtomicInMemoryDataset
+
+
+def _ase_dataset_reader(
+ rank: int,
+ world_size: int,
+ tmpdir: str,
+ ase_kwargs: dict,
+ atomicdata_kwargs: dict,
+ include_frames,
+ global_options: dict,
+) -> Union[str, List[AtomicData]]:
+ """Parallel reader for all frames in file."""
+ if world_size > 1:
+ from nequip.utils._global_options import _set_global_options
+
+ # ^ avoid import loop
+ # we only `multiprocessing` if world_size > 1
+ _set_global_options(global_options)
+ # interleave--- in theory it is better for performance for the ranks
+ # to read consecutive blocks, but the way ASE is written the whole
+ # file gets streamed through all ranks anyway, so just trust the OS
+ # to cache things sanely, which it will.
+ # ASE handles correctly the case where there are no frames in index
+ # and just gives an empty list, so that will succeed:
+ index = slice(rank, None, world_size)
+ if include_frames is None:
+ # count includes 0, 1, ..., inf
+ include_frames = itertools.count()
+
+ datas = []
+ # stream them from ase too using iread
+ for i, atoms in enumerate(ase.io.iread(**ase_kwargs, index=index, parallel=False)):
+ global_index = rank + (world_size * i)
+ datas.append(
+ (
+ global_index,
+ AtomicData.from_ase(atoms=atoms, **atomicdata_kwargs)
+ if global_index in include_frames
+ # in-memory dataset will ignore this later, but needed for indexing to work out
+ else None,
+ )
+ )
+ # Save to a tempfile---
+ # there can be a _lot_ of tensors here, and rather than dealing with
+ # the complications of running out of file descriptors and setting
+ # sharing methods, since this is a one time thing, just make it simple
+ # and avoid shared memory entirely.
+ if world_size > 1:
+ path = f"{tmpdir}/rank{rank}.pth"
+ torch.save(datas, path)
+ return path
+ else:
+ return datas
+
+
+class ASEDataset(AtomicInMemoryDataset):
+ """
+
+ Args:
+ ase_args (dict): arguments for ase.io.read
+ include_keys (list): in addition to forces and energy, the keys that needs to
+ be parsed into dataset
+ The data stored in ase.atoms.Atoms.array has the lowest priority,
+ and it will be overrided by data in ase.atoms.Atoms.info
+ and ase.atoms.Atoms.calc.results. Optional
+ key_mapping (dict): rename some of the keys to the value str. Optional
+
+ Example: Given an atomic data stored in "H2.extxyz" that looks like below:
+
+ ```H2.extxyz
+ 2
+ Properties=species:S:1:pos:R:3 energy=-10 user_label=2.0 pbc="F F F"
+ H 0.00000000 0.00000000 0.00000000
+ H 0.00000000 0.00000000 1.02000000
+ ```
+
+ The yaml input should be
+
+ ```
+ dataset: ase
+ dataset_file_name: H2.extxyz
+ ase_args:
+ format: extxyz
+ include_keys:
+ - user_label
+ key_mapping:
+ user_label: label0
+ chemical_symbols:
+ - H
+ ```
+
+ for VASP parser, the yaml input should be
+ ```
+ dataset: ase
+ dataset_file_name: OUTCAR
+ ase_args:
+ format: vasp-out
+ key_mapping:
+ free_energy: total_energy
+ chemical_symbols:
+ - H
+ ```
+
+ """
+
+ def __init__(
+ self,
+ root: str,
+ ase_args: dict = {},
+ file_name: Optional[str] = None,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: TypeMapper = None,
+ key_mapping: Optional[dict] = None,
+ include_keys: Optional[List[str]] = None,
+ ):
+ self.ase_args = {}
+ self.ase_args.update(getattr(type(self), "ASE_ARGS", dict()))
+ self.ase_args.update(ase_args)
+ assert "index" not in self.ase_args
+ assert "filename" not in self.ase_args
+
+ self.include_keys = include_keys
+ self.key_mapping = key_mapping
+
+ super().__init__(
+ file_name=file_name,
+ url=url,
+ root=root,
+ AtomicData_options=AtomicData_options,
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ @classmethod
+ def from_atoms_list(cls, atoms: Sequence[ase.Atoms], **kwargs):
+ """Make an ``ASEDataset`` from a list of ``ase.Atoms`` objects.
+
+ If `root` is not provided, a temporary directory will be used.
+
+ Please note that this is a convinience method that does NOT avoid a round-trip to disk; the provided ``atoms`` will be written out to a file.
+
+ Ignores ``kwargs["file_name"]`` if it is provided.
+
+ Args:
+ atoms
+ **kwargs: passed through to the constructor
+ Returns:
+ The constructed ``ASEDataset``.
+ """
+ if "root" not in kwargs:
+ tmpdir = tempfile.TemporaryDirectory()
+ kwargs["root"] = tmpdir.name
+ else:
+ tmpdir = None
+ kwargs["file_name"] = tmpdir.name + "/atoms.xyz"
+ atoms = list(atoms)
+ # Write them out
+ ase.io.write(kwargs["file_name"], atoms, format="extxyz")
+ # Read them in
+ obj = cls(**kwargs)
+ if tmpdir is not None:
+ # Make it keep a reference to the tmpdir to keep it alive
+ # When the dataset is garbage collected, the tmpdir will
+ # be too, and will (hopefully) get deleted eventually.
+ # Or at least by end of program...
+ obj._tmpdir_ref = tmpdir
+ return obj
+
+ @property
+ def raw_file_names(self):
+ return [basename(self.file_name)]
+
+ @property
+ def raw_dir(self):
+ return dirname(abspath(self.file_name))
+
+ def get_data(self):
+ ase_args = {"filename": self.raw_dir + "/" + self.raw_file_names[0]}
+ ase_args.update(self.ase_args)
+
+ # skip the None arguments
+ kwargs = dict(
+ include_keys=self.include_keys,
+ key_mapping=self.key_mapping,
+ )
+ kwargs = {k: v for k, v in kwargs.items() if v is not None}
+ kwargs.update(self.AtomicData_options)
+ n_proc = num_tasks()
+ with tempfile.TemporaryDirectory() as tmpdir:
+ from nequip.utils._global_options import _get_latest_global_options
+
+ # ^ avoid import loop
+ reader = functools.partial(
+ _ase_dataset_reader,
+ world_size=n_proc,
+ tmpdir=tmpdir,
+ ase_kwargs=ase_args,
+ atomicdata_kwargs=kwargs,
+ include_frames=self.include_frames,
+ # get the global options of the parent to initialize the worker correctly
+ global_options=_get_latest_global_options(),
+ )
+ if n_proc > 1:
+ # things hang for some obscure OpenMP reason on some systems when using `fork` method
+ ctx = mp.get_context("forkserver")
+ with ctx.Pool(processes=n_proc) as p:
+ # map it over the `rank` argument
+ datas = p.map(reader, list(range(n_proc)))
+ # clean up the pool before loading the data
+ datas = [torch.load(d) for d in datas]
+ datas = sum(datas, [])
+ # un-interleave the datas
+ datas = sorted(datas, key=lambda e: e[0])
+ else:
+ datas = reader(rank=0)
+ # datas here is already in order, stride 1 start 0
+ # no need to un-interleave
+ # return list of AtomicData:
+ return [e[1] for e in datas]
diff --git a/dptb/data/dataset/_base_datasets.py b/dptb/data/dataset/_base_datasets.py
new file mode 100644
index 00000000..8c43c1c0
--- /dev/null
+++ b/dptb/data/dataset/_base_datasets.py
@@ -0,0 +1,665 @@
+import numpy as np
+import logging
+import inspect
+import itertools
+import yaml
+import hashlib
+import math
+from typing import Tuple, Dict, Any, List, Callable, Union, Optional
+
+import torch
+
+from torch_runstats.scatter import scatter_std, scatter_mean
+
+from dptb.utils.torch_geometric import Batch, Dataset
+from dptb.utils.tools import download_url, extract_zip
+
+import dptb
+from dptb.data import (
+ AtomicData,
+ AtomicDataDict,
+ _NODE_FIELDS,
+ _EDGE_FIELDS,
+ _GRAPH_FIELDS,
+)
+from dptb.utils.batch_ops import bincount
+from dptb.utils.regressor import solver
+from dptb.utils.savenload import atomic_write
+from ..transforms import TypeMapper
+
+
+class AtomicDataset(Dataset):
+ """The base class for all NequIP datasets."""
+
+ root: str
+ dtype: torch.dtype
+
+ def __init__(
+ self,
+ root: str,
+ type_mapper: Optional[TypeMapper] = None,
+ ):
+ self.dtype = torch.get_default_dtype()
+ super().__init__(root=root, transform=type_mapper)
+
+ def statistics(
+ self,
+ fields: List[Union[str, Callable]],
+ modes: List[str],
+ stride: int = 1,
+ unbiased: bool = True,
+ kwargs: Optional[Dict[str, dict]] = {},
+ ) -> List[tuple]:
+ # TODO: If needed, this can eventually be implimented for general AtomicDataset by computing an online running mean and using Welford's method for a stable running standard deviation: https://jonisalonen.com/2013/deriving-welfords-method-for-computing-variance/
+ # That would be needed if we have lazy loading datasets.
+ # TODO: When lazy-loading datasets are implimented, how to deal with statistics, sampling, and subsets?
+ raise NotImplementedError("not implimented for general AtomicDataset yet")
+
+ @property
+ def type_mapper(self) -> Optional[TypeMapper]:
+ # self.transform is always a TypeMapper
+ return self.transform
+
+ def _get_parameters(self) -> Dict[str, Any]:
+ """Get a dict of the parameters used to build this dataset."""
+ pnames = list(inspect.signature(self.__init__).parameters)
+ IGNORE_KEYS = {
+ # the type mapper is applied after saving, not before, so doesn't matter to cache validity
+ "type_mapper"
+ }
+ params = {
+ k: getattr(self, k)
+ for k in pnames
+ if k not in IGNORE_KEYS and hasattr(self, k)
+ }
+ # Add other relevant metadata:
+ params["dtype"] = str(self.dtype)
+ params["nequip_version"] = dptb.__version__
+
+ return params
+
+ @property
+ def processed_dir(self) -> str:
+ # We want the file name to change when the parameters change
+ # So, first we get all parameters:
+ params = self._get_parameters()
+ # Make some kind of string of them:
+ # we don't care about this possibly changing between python versions,
+ # since a change in python version almost certainly means a change in
+ # versions of other things too, and is a good reason to recompute
+ buffer = yaml.dump(params).encode("ascii")
+ # And hash it:
+ param_hash = hashlib.sha1(buffer).hexdigest()
+ return f"{self.root}/processed_dataset_{param_hash}"
+
+
+class AtomicInMemoryDataset(AtomicDataset):
+ r"""Base class for all datasets that fit in memory.
+
+ Please note that, as a ``pytorch_geometric`` dataset, it must be backed by some kind of disk storage.
+ By default, the raw file will be stored at root/raw and the processed torch
+ file will be at root/process.
+
+ Subclasses must implement:
+ - ``raw_file_names``
+ - ``get_data()``
+
+ Subclasses may implement:
+ - ``download()`` or ``self.url`` or ``ClassName.URL``
+
+ Args:
+ root (str, optional): Root directory where the dataset should be saved. Defaults to current working directory.
+ file_name (str, optional): file name of data source. only used in children class
+ url (str, optional): url to download data source
+ AtomicData_options (dict, optional): extra key that are not stored in data but needed for AtomicData initialization
+ include_frames (list, optional): the frames to process with the constructor.
+ type_mapper (TypeMapper): the transformation to map atomic information to species index. Optional
+ """
+
+ def __init__(
+ self,
+ root: str,
+ file_name: Optional[str] = None,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: Optional[TypeMapper] = None,
+ ):
+ # TO DO, this may be simplified
+ # See if a subclass defines some inputs
+ self.file_name = (
+ getattr(type(self), "FILE_NAME", None) if file_name is None else file_name
+ )
+ self.url = getattr(type(self), "URL", url)
+
+ self.AtomicData_options = AtomicData_options
+ self.include_frames = include_frames
+
+ self.data = None
+
+ # !!! don't delete this block.
+ # otherwise the inherent children class
+ # will ignore the download function here
+ class_type = type(self)
+ if class_type != AtomicInMemoryDataset:
+ if "download" not in self.__class__.__dict__:
+ class_type.download = AtomicInMemoryDataset.download
+ if "process" not in self.__class__.__dict__:
+ class_type.process = AtomicInMemoryDataset.process
+
+ # Initialize the InMemoryDataset, which runs download and process
+ # See https://pytorch-geometric.readthedocs.io/en/latest/notes/create_dataset.html#creating-in-memory-datasets
+ # Then pre-process the data if disk files are not found
+ super().__init__(root=root, type_mapper=type_mapper)
+ if self.data is None:
+ self.data, include_frames = torch.load(self.processed_paths[0])
+ if not np.all(include_frames == self.include_frames):
+ raise ValueError(
+ f"the include_frames is changed. "
+ f"please delete the processed folder and rerun {self.processed_paths[0]}"
+ )
+
+ def len(self):
+ if self.data is None:
+ return 0
+ return self.data.num_graphs
+
+ @property
+ def raw_file_names(self):
+ raise NotImplementedError()
+
+ @property
+ def processed_file_names(self) -> List[str]:
+ return ["data.pth", "params.yaml"]
+
+ def get_data(
+ self,
+ ) -> Union[Tuple[Dict[str, Any], Dict[str, Any]], List[AtomicData]]:
+ """Get the data --- called from ``process()``, can assume that ``raw_file_names()`` exist.
+
+ Note that parameters for graph construction such as ``pbc`` and ``r_max`` should be included here as (likely, but not necessarily, fixed) fields.
+
+ Returns:
+ A dict:
+ fields: dict
+ mapping a field name ('pos', 'cell') to a list-like sequence of tensor-like objects giving that field's value for each example.
+ Or:
+ data_list: List[AtomicData]
+ """
+ raise NotImplementedError
+
+ def download(self):
+ if (not hasattr(self, "url")) or (self.url is None):
+ # Don't download, assume present. Later could have FileNotFound if the files don't actually exist
+ pass
+ else:
+ download_path = download_url(self.url, self.raw_dir)
+ if download_path.endswith(".zip"):
+ extract_zip(download_path, self.raw_dir)
+
+ def process(self):
+ data = self.get_data() ## get data returns either a list of AtomicData class or a data dict
+ if isinstance(data, list):
+
+ # It's a data list
+ data_list = data
+ if not (self.include_frames is None or data_list is None):
+ data_list = [data_list[i] for i in self.include_frames] # 可以选择数据集中加载的序号
+ assert all(isinstance(e, AtomicData) for e in data_list)
+ assert all(AtomicDataDict.BATCH_KEY not in e for e in data_list)
+
+ fields = {}
+
+ elif isinstance(data, dict):
+ # It's fields
+ # Get our data
+ fields = data
+
+ # check keys
+ all_keys = set(fields.keys())
+ assert AtomicDataDict.BATCH_KEY not in all_keys
+ # Check bad key combinations, but don't require that this be a graph yet.
+ AtomicDataDict.validate_keys(all_keys, graph_required=False)
+
+ # check dimesionality
+ num_examples = set([len(a) for a in fields.values()])
+ if not len(num_examples) == 1:
+ raise ValueError(
+ f"This dataset is invalid: expected all fields to have same length (same number of examples), but they had shapes { {f: v.shape for f, v in fields.items() } }"
+ )
+ num_examples = next(iter(num_examples))
+
+ include_frames = self.include_frames
+ if include_frames is None:
+ include_frames = range(num_examples)
+
+ # Make AtomicData from it:
+ if AtomicDataDict.EDGE_INDEX_KEY in all_keys:
+ # This is already a graph, just build it
+ constructor = AtomicData
+ else:
+ # do neighborlist from points
+ constructor = AtomicData.from_points
+ assert "r_max" in self.AtomicData_options
+ assert AtomicDataDict.POSITIONS_KEY in all_keys
+
+ data_list = [
+ constructor(
+ **{
+ **{f: v[i] for f, v in fields.items()},
+ **self.AtomicData_options,
+ }
+ )
+ for i in include_frames
+ ]
+
+
+ else:
+ raise ValueError("Invalid return from `self.get_data()`")
+
+ # Batch it for efficient saving
+ # This limits an AtomicInMemoryDataset to a maximum of LONG_MAX atoms _overall_, but that is a very big number and any dataset that large is probably not "InMemory" anyway
+ data = Batch.from_data_list(data_list)
+ del data_list
+ del fields
+
+ total_MBs = sum(item.numel() * item.element_size() for _, item in data) / (
+ 1024 * 1024
+ )
+ logging.info(
+ f"Loaded data: {data}\n processed data size: ~{total_MBs:.2f} MB"
+ )
+ del total_MBs
+
+ # use atomic writes to avoid race conditions between
+ # different trainings that use the same dataset
+ # since those separate trainings should all produce the same results,
+ # it doesn't matter if they overwrite each others cached'
+ # datasets. It only matters that they don't simultaneously try
+ # to write the _same_ file, corrupting it.
+ with atomic_write(self.processed_paths[0], binary=True) as f:
+ torch.save((data, self.include_frames), f)
+ with atomic_write(self.processed_paths[1], binary=False) as f:
+ yaml.dump(self._get_parameters(), f)
+
+ logging.info("Cached processed data to disk")
+
+ self.data = data
+
+ def get(self, idx):
+ return self.data.get_example(idx)
+
+ def _selectors(
+ self,
+ stride: int = 1,
+ ):
+ if self._indices is not None:
+ graph_selector = torch.as_tensor(self._indices)[::stride]
+ # note that self._indices is _not_ necessarily in order,
+ # while self.data --- which we take our arrays from ---
+ # is always in the original order.
+ # In particular, the values of `self.data.batch`
+ # are indexes in the ORIGINAL order
+ # thus we need graph level properties to also be in the original order
+ # so that batch values index into them correctly
+ # since self.data.batch is always sorted & contiguous
+ # (because of Batch.from_data_list)
+ # we sort it:
+ graph_selector, _ = torch.sort(graph_selector)
+ else:
+ graph_selector = torch.arange(0, self.len(), stride)
+
+ node_selector = torch.as_tensor(
+ np.in1d(self.data.batch.numpy(), graph_selector.numpy())
+ )
+
+ edge_index = self.data[AtomicDataDict.EDGE_INDEX_KEY]
+ edge_selector = node_selector[edge_index[0]] & node_selector[edge_index[1]]
+
+ return (graph_selector, node_selector, edge_selector)
+
+ def statistics(
+ self,
+ fields: List[Union[str, Callable]],
+ modes: List[str],
+ stride: int = 1,
+ unbiased: bool = True,
+ kwargs: Optional[Dict[str, dict]] = {},
+ ) -> List[tuple]:
+ """Compute the statistics of ``fields`` in the dataset.
+
+ If the values at the fields are vectors/multidimensional, they must be of fixed shape and elementwise statistics will be computed.
+
+ Args:
+ fields: the names of the fields to compute statistics for.
+ Instead of a field name, a callable can also be given that reuturns a quantity to compute the statisics for.
+
+ If a callable is given, it will be called with a (possibly batched) ``Data``-like object and must return a sequence of points to add to the set over which the statistics will be computed.
+ The callable must also return a string, one of ``"node"`` or ``"graph"``, indicating whether the value it returns is a per-node or per-graph quantity.
+ PLEASE NOTE: the argument to the callable may be "batched", and it may not be batched "contiguously": ``batch`` and ``edge_index`` may have "gaps" in their values.
+
+ For example, to compute the overall statistics of the x,y, and z components of a per-node vector ``force`` field:
+
+ data.statistics([lambda data: (data.force.flatten(), "node")])
+
+ The above computes the statistics over a set of size 3N, where N is the total number of nodes in the dataset.
+
+ modes: the statistic to compute for each field. Valid options are:
+ - ``count``
+ - ``rms``
+ - ``mean_std``
+ - ``per_atom_*``
+ - ``per_species_*``
+
+ stride: the stride over the dataset while computing statistcs.
+
+ unbiased: whether to use unbiased for standard deviations.
+
+ kwargs: other options for individual statistics modes.
+
+ Returns:
+ List of statistics. For fields of floating dtype the statistics are the two-tuple (mean, std); for fields of integer dtype the statistics are a one-tuple (bincounts,)
+ """
+
+ # Short circut:
+ assert len(modes) == len(fields)
+ if len(fields) == 0:
+ return []
+
+ graph_selector, node_selector, edge_selector = self._selectors(stride=stride)
+
+ num_graphs = len(graph_selector)
+ num_nodes = node_selector.sum()
+ num_edges = edge_selector.sum()
+
+ if self.transform is not None:
+ # pre-transform the data so that statistics process transformed data
+ data_transformed = self.transform(self.data.to_dict(), types_required=False)
+ else:
+ data_transformed = self.data.to_dict()
+ # pre-select arrays
+ # this ensures that all following computations use the right data
+ all_keys = set()
+ selectors = {}
+ for k in data_transformed.keys():
+ all_keys.add(k)
+ if k in _NODE_FIELDS:
+ selectors[k] = node_selector
+ elif k in _GRAPH_FIELDS:
+ selectors[k] = graph_selector
+ elif k == AtomicDataDict.EDGE_INDEX_KEY:
+ selectors[k] = (slice(None, None, None), edge_selector)
+ elif k in _EDGE_FIELDS:
+ selectors[k] = edge_selector
+ # TODO: do the batch indexes, edge_indexes, etc. after selection need to be
+ # "compacted" to subtract out their offsets? For now, we just punt this
+ # onto the writer of the callable field.
+ # apply selector to actual data
+ data_transformed = {
+ k: data_transformed[k][selectors[k]]
+ for k in data_transformed.keys()
+ if k in selectors
+ }
+
+ atom_types: Optional[torch.Tensor] = None
+ out: list = []
+ for ifield, field in enumerate(fields):
+ if callable(field):
+ # make a joined thing? so it includes fixed fields
+ arr, arr_is_per = field(data_transformed)
+ arr = arr.to(self.dtype) # all statistics must be on floating
+ assert arr_is_per in ("node", "graph", "edge")
+ else:
+ if field not in all_keys:
+ raise RuntimeError(
+ f"The field key `{field}` is not present in this dataset"
+ )
+ if field not in selectors:
+ # this means field is not selected and so not available
+ raise RuntimeError(
+ f"Only per-node and per-graph fields can have statistics computed; `{field}` has not been registered as either. If it is per-node or per-graph, please register it as such using `nequip.data.register_fields`"
+ )
+ arr = data_transformed[field]
+ if field in _NODE_FIELDS:
+ arr_is_per = "node"
+ elif field in _GRAPH_FIELDS:
+ arr_is_per = "graph"
+ elif field in _EDGE_FIELDS:
+ arr_is_per = "edge"
+ else:
+ raise RuntimeError
+
+ # Check arr
+ if arr is None:
+ raise ValueError(
+ f"Cannot compute statistics over field `{field}` whose value is None!"
+ )
+ if not isinstance(arr, torch.Tensor):
+ if np.issubdtype(arr.dtype, np.floating):
+ arr = torch.as_tensor(arr, dtype=self.dtype)
+ else:
+ arr = torch.as_tensor(arr)
+ if arr_is_per == "node":
+ arr = arr.view(num_nodes, -1)
+ elif arr_is_per == "graph":
+ arr = arr.view(num_graphs, -1)
+ elif arr_is_per == "edge":
+ arr = arr.view(num_edges, -1)
+
+ ana_mode = modes[ifield]
+ # compute statistics
+ if ana_mode == "count":
+ # count integers
+ uniq, counts = torch.unique(
+ torch.flatten(arr), return_counts=True, sorted=True
+ )
+ out.append((uniq, counts))
+ elif ana_mode == "rms":
+ # root-mean-square
+ out.append((torch.sqrt(torch.mean(arr * arr)),))
+
+ elif ana_mode == "mean_std":
+ # mean and std
+ if len(arr) < 2:
+ raise ValueError(
+ "Can't do per species standard deviation without at least two samples"
+ )
+ mean = torch.mean(arr, dim=0)
+ std = torch.std(arr, dim=0, unbiased=unbiased)
+ out.append((mean, std))
+
+ elif ana_mode == "absmax":
+ out.append((arr.abs().max(),))
+
+ elif ana_mode.startswith("per_species_"):
+ # per-species
+ algorithm_kwargs = kwargs.pop(field + ana_mode, {})
+
+ ana_mode = ana_mode[len("per_species_") :]
+
+ if atom_types is None:
+ atom_types = data_transformed[AtomicDataDict.ATOM_TYPE_KEY]
+
+ results = self._per_species_statistics(
+ ana_mode,
+ arr,
+ arr_is_per=arr_is_per,
+ batch=data_transformed[AtomicDataDict.BATCH_KEY],
+ atom_types=atom_types,
+ unbiased=unbiased,
+ algorithm_kwargs=algorithm_kwargs,
+ )
+ out.append(results)
+
+ elif ana_mode.startswith("per_atom_"):
+ # per-atom
+ # only makes sense for a per-graph quantity
+ if arr_is_per != "graph":
+ raise ValueError(
+ f"It doesn't make sense to ask for `{ana_mode}` since `{field}` is not per-graph"
+ )
+ ana_mode = ana_mode[len("per_atom_") :]
+ results = self._per_atom_statistics(
+ ana_mode=ana_mode,
+ arr=arr,
+ batch=data_transformed[AtomicDataDict.BATCH_KEY],
+ unbiased=unbiased,
+ )
+ out.append(results)
+
+ else:
+ raise NotImplementedError(f"Cannot handle statistics mode {ana_mode}")
+
+ return out
+
+ @staticmethod
+ def _per_atom_statistics(
+ ana_mode: str,
+ arr: torch.Tensor,
+ batch: torch.Tensor,
+ unbiased: bool = True,
+ ):
+ """Compute "per-atom" statistics that are normalized by the number of atoms in the system.
+
+ Only makes sense for a graph-level quantity (checked by .statistics).
+ """
+ # using unique_consecutive handles the non-contiguous selected batch index
+ _, N = torch.unique_consecutive(batch, return_counts=True)
+ N = N.unsqueeze(-1)
+ assert N.ndim == 2
+ assert N.shape == (len(arr), 1)
+ assert arr.ndim >= 2
+ data_dim = arr.shape[1:]
+ arr = arr / N
+ assert arr.shape == (len(N),) + data_dim
+ if ana_mode == "mean_std":
+ if len(arr) < 2:
+ raise ValueError(
+ "Can't do standard deviation without at least two samples"
+ )
+ mean = torch.mean(arr, dim=0)
+ std = torch.std(arr, unbiased=unbiased, dim=0)
+ return mean, std
+ elif ana_mode == "rms":
+ return (torch.sqrt(torch.mean(arr.square())),)
+ elif ana_mode == "absmax":
+ return (torch.max(arr.abs()),)
+ else:
+ raise NotImplementedError(
+ f"{ana_mode} for per-atom analysis is not implemented"
+ )
+
+ def _per_species_statistics(
+ self,
+ ana_mode: str,
+ arr: torch.Tensor,
+ arr_is_per: str,
+ atom_types: torch.Tensor,
+ batch: torch.Tensor,
+ unbiased: bool = True,
+ algorithm_kwargs: Optional[dict] = {},
+ ):
+ """Compute "per-species" statistics.
+
+ For a graph-level quantity, models it as a linear combintation of the number of atoms of different types in the graph.
+
+ For a per-node quantity, computes the expected statistic but for each type instead of over all nodes.
+ """
+ N = bincount(atom_types.squeeze(-1), batch)
+ assert N.ndim == 2 # [batch, n_type]
+ N = N[(N > 0).any(dim=1)] # deal with non-contiguous batch indexes
+ assert arr.ndim >= 2
+ if arr_is_per == "graph":
+
+ if ana_mode != "mean_std":
+ raise NotImplementedError(
+ f"{ana_mode} for per species analysis is not implemented for shape {arr.shape}"
+ )
+
+ N = N.type(self.dtype)
+
+ return solver(N, arr, **algorithm_kwargs)
+
+ elif arr_is_per == "node":
+ arr = arr.type(self.dtype)
+
+ if ana_mode == "mean_std":
+ # There need to be at least two occurances of each atom type in the
+ # WHOLE dataset, not in any given frame:
+ if torch.any(N.sum(dim=0) < 2):
+ raise ValueError(
+ "Can't do per species standard deviation without at least two samples per species"
+ )
+ mean = scatter_mean(arr, atom_types, dim=0)
+ assert mean.shape[1:] == arr.shape[1:] # [N, dims] -> [type, dims]
+ assert len(mean) == N.shape[1]
+ std = scatter_std(arr, atom_types, dim=0, unbiased=unbiased)
+ assert std.shape == mean.shape
+ return mean, std
+ elif ana_mode == "rms":
+ square = scatter_mean(arr.square(), atom_types, dim=0)
+ assert square.shape[1:] == arr.shape[1:] # [N, dims] -> [type, dims]
+ assert len(square) == N.shape[1]
+ dims = len(square.shape) - 1
+ for i in range(dims):
+ square = square.mean(axis=-1)
+ return (torch.sqrt(square),)
+ else:
+ raise NotImplementedError(
+ f"Statistics mode {ana_mode} isn't yet implemented for per_species_"
+ )
+
+ else:
+ raise NotImplementedError
+
+ def rdf(
+ self, bin_width: float, stride: int = 1
+ ) -> Dict[Tuple[int, int], Tuple[np.ndarray, np.ndarray]]:
+ """Compute the pairwise RDFs of the dataset.
+
+ Args:
+ bin_width: width of the histogram bin in distance units
+ stride: stride of data to include
+
+ Returns:
+ dictionary mapping `(type1, type2)` to tuples of `(hist, bin_edges)` in the style of `np.histogram`.
+ """
+ graph_selector, node_selector, edge_selector = self._selectors(stride=stride)
+
+ data = AtomicData.to_AtomicDataDict(self.data)
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ results = {}
+
+ types = self.type_mapper(data)[AtomicDataDict.ATOM_TYPE_KEY]
+
+ edge_types = torch.index_select(
+ types, 0, data[AtomicDataDict.EDGE_INDEX_KEY].reshape(-1)
+ ).view(2, -1)
+ types_center = edge_types[0].numpy()
+ types_neigh = edge_types[1].numpy()
+
+ r_max: float = self.AtomicData_options["r_max"]
+ # + 1 to always have a zero bin at the end
+ n_bins: int = int(math.ceil(r_max / bin_width)) + 1
+ # +1 since these are bin_edges including rightmost
+ bins = bin_width * np.arange(n_bins + 1)
+
+ for type1, type2 in itertools.combinations_with_replacement(
+ range(self.type_mapper.num_types), 2
+ ):
+ # Try to do as much of this as possible in-place
+ mask = types_center == type1
+ np.logical_and(mask, types_neigh == type2, out=mask)
+ np.logical_and(mask, edge_selector, out=mask)
+ mask = mask.astype(np.int32)
+ results[(type1, type2)] = np.histogram(
+ data[AtomicDataDict.EDGE_LENGTH_KEY],
+ weights=mask,
+ bins=bins,
+ density=True,
+ )
+ # RDF is symmetric
+ results[(type2, type1)] = results[(type1, type2)]
+
+ return results
diff --git a/dptb/data/dataset/_deeph_dataset.py b/dptb/data/dataset/_deeph_dataset.py
new file mode 100644
index 00000000..2485ce1b
--- /dev/null
+++ b/dptb/data/dataset/_deeph_dataset.py
@@ -0,0 +1,79 @@
+from typing import Dict, Any, List, Callable, Union, Optional
+import os
+import numpy as np
+import h5py
+
+import torch
+
+from .. import (
+ AtomicData,
+ AtomicDataDict,
+)
+from ..transforms import TypeMapper, OrbitalMapper
+from ._base_datasets import AtomicDataset
+from dptb.nn.hamiltonian import E3Hamiltonian
+from dptb.data.interfaces.ham_to_feature import openmx_to_deeptb
+
+orbitalLId = {0:"s", 1:"p", 2:"d", 3:"f"}
+
+class DeePHE3Dataset(AtomicDataset):
+
+ def __init__(
+ self,
+ root: str,
+ key_mapping: Dict[str, str] = {
+ "pos": AtomicDataDict.POSITIONS_KEY,
+ "energy": AtomicDataDict.TOTAL_ENERGY_KEY,
+ "atomic_numbers": AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ "kpoints": AtomicDataDict.KPOINT_KEY,
+ "eigenvalues": AtomicDataDict.ENERGY_EIGENVALUE_KEY,
+ },
+ preprocess_path: str = None,
+ subdir_names: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ type_mapper: Optional[TypeMapper] = None,
+ ):
+ super().__init__(root=root, type_mapper=type_mapper)
+ self.key_mapping = key_mapping
+ self.key_list = list(key_mapping.keys())
+ self.value_list = list(key_mapping.values())
+ self.subdir_names = subdir_names
+ self.preprocess_path = preprocess_path
+
+ self.AtomicData_options = AtomicData_options
+ # self.r_max = AtomicData_options["r_max"]
+ # self.er_max = AtomicData_options["er_max"]
+ # self.oer_max = AtomicData_options["oer_max"]
+ # self.pbc = AtomicData_options["pbc"]
+
+ self.index = None
+ self.num_examples = len(subdir_names)
+
+ def get(self, idx):
+ file_name = self.subdir_names[idx]
+ file = os.path.join(self.preprocess_path, file_name)
+
+ if os.path.exists(os.path.join(file, "AtomicData.pth")):
+ atomic_data = torch.load(os.path.join(file, "AtomicData.pth"))
+ else:
+ atomic_data = AtomicData.from_points(
+ pos = np.loadtxt(os.path.join(file, "site_positions.dat")).T,
+ cell = np.loadtxt(os.path.join(file, "lat.dat")).T,
+ atomic_numbers = np.loadtxt(os.path.join(file, "element.dat")),
+ **self.AtomicData_options,
+ )
+
+ idp = self.type_mapper
+ # e3 = E3Hamiltonian(idp=idp, decompose=True)
+
+ openmx_to_deeptb(atomic_data, idp, os.path.join(file, "./hamiltonians.h5"))
+ # with torch.no_grad():
+ # atomic_data = e3(atomic_data.to_dict())
+ # atomic_data = AtomicData.from_dict(atomic_data)
+
+ torch.save(atomic_data, os.path.join(file, "AtomicData.pth"))
+
+ return atomic_data
+
+ def len(self) -> int:
+ return self.num_examples
\ No newline at end of file
diff --git a/dptb/data/dataset/_default_dataset.py b/dptb/data/dataset/_default_dataset.py
new file mode 100644
index 00000000..4a0d7f30
--- /dev/null
+++ b/dptb/data/dataset/_default_dataset.py
@@ -0,0 +1,425 @@
+from typing import Dict, Any, List, Callable, Union, Optional
+import os
+import glob
+
+import numpy as np
+import h5py
+from ase import Atoms
+from ase.io import Trajectory
+
+import torch
+
+from .. import (
+ AtomicData,
+ AtomicDataDict,
+)
+from ..transforms import TypeMapper, OrbitalMapper
+from ._base_datasets import AtomicDataset, AtomicInMemoryDataset
+#from dptb.nn.hamiltonian import E3Hamiltonian
+from dptb.data.interfaces.ham_to_feature import ham_block_to_feature
+from dptb.utils.tools import j_loader
+from dptb.data.AtomicDataDict import with_edge_vectors
+from dptb.nn.hamiltonian import E3Hamiltonian
+
+class _TrajData(object):
+ '''
+ Input files format in a trajectory (shape):
+ "info.json": optional, includes infomation in the data files.
+ can be provided in the base (upper level) folder, or assign in each trajectory.
+ "cell.dat": fixed cell (3, 3) or variable cells (nframes, 3, 3). Unit: Angstrom
+ "atomic_numbers.dat": (natoms) or (nframes, natoms)
+ "positions.dat": concentrate all positions in one file, (nframes * natoms, 3). Can be cart or frac.
+
+ Optional data files:
+ "eigenvalues.npy": concentrate all engenvalues in one file, (nframes, nkpoints, nbands)
+ "kpoints.npy": MUST be provided when loading `eigenvalues.npy`, (nkpoints, 3) or (nframes, nkpints, 3)
+ "hamiltonians.h5": h5 file storing atom-wise hamiltonian blocks labeled by frames id and `i0_jR_Rx_Ry_Rz`.
+ "overlaps.h5": the same format of overlap blocks as `hamiltonians.h5`
+ '''
+
+ def __init__(self,
+ root: str,
+ AtomicData_options: Dict[str, Any] = {},
+ get_Hamiltonian = False,
+ get_eigenvalues = False,
+ info = None,
+ _clear = False):
+ self.root = root
+ self.AtomicData_options = AtomicData_options
+ self.info = info
+
+ self.data = {}
+ # load cell
+ cell = np.loadtxt(os.path.join(root, "cell.dat"))
+ if cell.shape[0] == 3:
+ # same cell size, then copy it to all frames.
+ cell = np.expand_dims(cell, axis=0)
+ self.data["cell"] = np.broadcast_to(cell, (self.info["nframes"], 3, 3))
+ elif cell.shape[0] == self.info["nframes"] * 3:
+ self.data["cell"] = cell.reshape(self.info["nframes"], 3, 3)
+ else:
+ raise ValueError("Wrong cell dimensions.")
+
+ # load atomic numbers
+ atomic_numbers = np.loadtxt(os.path.join(root, "atomic_numbers.dat"))
+ if atomic_numbers.shape[0] == self.info["natoms"]:
+ # same atomic_numbers, copy it to all frames.
+ atomic_numbers = np.expand_dims(atomic_numbers, axis=0)
+ self.data["atomic_numbers"] = np.broadcast_to(atomic_numbers, (self.info["nframes"],
+ self.info["natoms"]))
+ elif atomic_numbers.shape[0] == self.info["natoms"] * self.info["nframes"]:
+ self.data["atomic_numbers"] = atomic_numbers.reshape(self.info["nframes"],
+ self.info["natoms"])
+ else:
+ raise ValueError("Wrong atomic_number dimensions.")
+
+ # load positions, stored as cartesion no matter what provided.
+ pos = np.loadtxt(os.path.join(root, "positions.dat"))
+ assert pos.shape[0] == self.info["nframes"] * self.info["natoms"]
+ pos = pos.reshape(self.info["nframes"], self.info["natoms"], 3)
+ # ase use cartesian by default.
+ if self.info["pos_type"] == "cart" or self.info["pos_type"] == "ase":
+ self.data["pos"] = pos
+ elif self.info["pos_type"] == "frac":
+ self.data["pos"] = pos @ self.data["cell"]
+ else:
+ raise NameError("Position type must be cart / frac.")
+
+ # load optional data files
+ if os.path.exists(os.path.join(self.root, "eigenvalues.npy")) and get_eigenvalues==True:
+ assert "bandinfo" in self.info, "`bandinfo` must be provided in `info.json` for loading eigenvalues."
+ assert os.path.exists(os.path.join(self.root, "kpoints.npy"))
+ kpoints = np.load(os.path.join(self.root, "kpoints.npy"))
+ if kpoints.ndim == 2:
+ # only one frame or same kpoints, then copy it to all frames.
+ # shape: (nkpoints, 3)
+ kpoints = np.expand_dims(kpoints, axis=0)
+ self.data["kpoints"] = np.broadcast_to(kpoints, (self.info["nframes"],
+ kpoints.shape[1], 3))
+ elif kpoints.ndim == 3 and kpoints.shape[0] == self.info["nframes"]:
+ # array of kpoints, (nframes, nkpoints, 3)
+ self.data["kpoints"] = kpoints
+ else:
+ raise ValueError("Wrong kpoint dimensions.")
+ eigenvalues = np.load(os.path.join(self.root, "eigenvalues.npy"))
+ # special case: trajectory contains only one frame
+ if eigenvalues.ndim == 2:
+ eigenvalues = np.expand_dims(eigenvalues, axis=0)
+ assert eigenvalues.shape[0] == self.info["nframes"]
+ assert eigenvalues.shape[1] == self.data["kpoints"].shape[1]
+ self.data["eigenvalues"] = eigenvalues
+ if os.path.exists(os.path.join(self.root, "hamiltonians.h5")) and get_Hamiltonian==True:
+ self.data["hamiltonian_blocks"] = h5py.File(os.path.join(self.root, "hamiltonians.h5"), "r")
+ if os.path.exists(os.path.join(self.root, "overlaps.h5")):
+ self.data["overlap_blocks"] = h5py.File(os.path.join(self.root, "overlaps.h5"), "r")
+
+ # this is used to clear the tmp files to load ase trajectory only.
+ if _clear:
+ os.remove(os.path.join(root, "positions.dat"))
+ os.remove(os.path.join(root, "cell.dat"))
+ os.remove(os.path.join(root, "atomic_numbers.dat"))
+
+ @classmethod
+ def from_ase_traj(cls,
+ root: str,
+ AtomicData_options: Dict[str, Any] = {},
+ get_Hamiltonian = False,
+ get_eigenvalues = False,
+ info = None):
+
+ traj_file = glob.glob(f"{root}/*.traj")
+ assert len(traj_file) == 1, print("only one ase trajectory file can be provided.")
+ traj = Trajectory(traj_file[0], 'r')
+ positions = []
+ cell = []
+ atomic_numbers = []
+ for atoms in traj:
+ positions.append(atoms.get_positions())
+ cell.append(atoms.get_cell())
+ atomic_numbers.append(atoms.get_atomic_numbers())
+ positions = np.array(positions)
+ positions = positions.reshape(-1, 3)
+ cell = np.array(cell)
+ cell = cell.reshape(-1, 3)
+ atomic_numbers = np.array(atomic_numbers)
+ atomic_numbers = atomic_numbers.reshape(-1, 1)
+ np.savetxt(os.path.join(root, "positions.dat"), positions)
+ np.savetxt(os.path.join(root, "cell.dat"), cell)
+ np.savetxt(os.path.join(root, "atomic_numbers.dat"), atomic_numbers, fmt='%d')
+
+ return cls(root=root,
+ AtomicData_options=AtomicData_options,
+ get_Hamiltonian=get_Hamiltonian,
+ get_eigenvalues=get_eigenvalues,
+ info=info,
+ _clear=True)
+
+ def toAtomicDataList(self, idp: TypeMapper = None):
+ data_list = []
+ for frame in range(self.info["nframes"]):
+ atomic_data = AtomicData.from_points(
+ pos = self.data["pos"][frame][:],
+ cell = self.data["cell"][frame][:],
+ atomic_numbers = self.data["atomic_numbers"][frame],
+ # pbc is stored in AtomicData_options now.
+ #pbc = self.info["pbc"],
+ **self.AtomicData_options)
+ if "hamiltonian_blocks" in self.data:
+ assert idp is not None, "LCAO Basis must be provided in `common_option` for loading Hamiltonian."
+ if "overlap_blocks" not in self.data:
+ self.data["overlap_blocks"] = [False] * self.info["nframes"]
+ # e3 = E3Hamiltonian(idp=idp, decompose=True)
+ ham_block_to_feature(atomic_data, idp,
+ self.data["hamiltonian_blocks"][str(frame+1)],
+ self.data["overlap_blocks"][str(frame+1)])
+
+ # TODO: initialize the edge and node feature tempretely, there should be a better way.
+ else:
+ # just temporarily initialize the edge and node feature to zeros, to let the batch collate work.
+ atomic_data[AtomicDataDict.EDGE_FEATURES_KEY] = torch.zeros(atomic_data[AtomicDataDict.EDGE_INDEX_KEY].shape[1], 1)
+ atomic_data[AtomicDataDict.NODE_FEATURES_KEY] = torch.zeros(atomic_data[AtomicDataDict.POSITIONS_KEY].shape[0], 1)
+ atomic_data[AtomicDataDict.EDGE_OVERLAP_KEY] = torch.zeros(atomic_data[AtomicDataDict.EDGE_INDEX_KEY].shape[1], 1)
+ # with torch.no_grad():
+ # atomic_data = e3(atomic_data.to_dict())
+ # atomic_data = AtomicData.from_dict(atomic_data)
+ if "eigenvalues" in self.data and "kpoints" in self.data:
+ assert "bandinfo" in self.info, "`bandinfo` must be provided in `info.json` for loading eigenvalues."
+ bandinfo = self.info["bandinfo"]
+ atomic_data[AtomicDataDict.KPOINT_KEY] = torch.as_tensor(self.data["kpoints"][frame][:],
+ dtype=torch.get_default_dtype())
+ if bandinfo["emin"] is not None and bandinfo["emax"] is not None:
+ atomic_data[AtomicDataDict.ENERGY_WINDOWS_KEY] = torch.as_tensor([bandinfo["emin"], bandinfo["emax"]],
+ dtype=torch.get_default_dtype())
+ if bandinfo["band_min"] is not None and bandinfo["band_max"] is not None:
+ atomic_data[AtomicDataDict.BAND_WINDOW_KEY] = torch.as_tensor([bandinfo["band_min"], bandinfo["band_max"]],
+ dtype=torch.long)
+ # atomic_data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] = torch.as_tensor(self.data["eigenvalues"][frame][:, bandinfo["band_min"]:bandinfo["band_max"]],
+ # dtype=torch.get_default_dtype())
+ atomic_data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] = torch.as_tensor(self.data["eigenvalues"][frame],
+ dtype=torch.get_default_dtype())
+ data_list.append(atomic_data)
+ return data_list
+
+
+class DefaultDataset(AtomicInMemoryDataset):
+
+ def __init__(
+ self,
+ root: str,
+ info_files: Dict[str, Dict],
+ url: Optional[str] = None, # seems useless but can't be remove
+ include_frames: Optional[List[int]] = None, # maybe support in future
+ type_mapper: TypeMapper = None,
+ get_Hamiltonian: bool = False,
+ get_eigenvalues: bool = False,
+ ):
+ self.root = root
+ self.url = url
+ self.info_files = info_files
+ # The following flags are stored to label dataset.
+ self.get_Hamiltonian = get_Hamiltonian
+ self.get_eigenvalues = get_eigenvalues
+
+ # load all data files
+ self.raw_data = []
+ for file in self.info_files.keys():
+ # get the info here
+ info = info_files[file]
+ assert "AtomicData_options" in info
+ AtomicData_options = info["AtomicData_options"]
+ assert "r_max" in AtomicData_options
+ assert "pbc" in AtomicData_options
+ if info["pos_type"] == "ase":
+ subdata = _TrajData.from_ase_traj(os.path.join(self.root, file),
+ AtomicData_options,
+ get_Hamiltonian,
+ get_eigenvalues,
+ info=info)
+ else:
+ subdata = _TrajData(os.path.join(self.root, file),
+ AtomicData_options,
+ get_Hamiltonian,
+ get_eigenvalues,
+ info=info)
+ self.raw_data.append(subdata)
+
+ # The AtomicData_options is never used here.
+ # Because we always return a list of AtomicData object in `get_data()`.
+ # That is, AtomicInMemoryDataset will not use AtomicData_options to build any AtomicData here.
+ super().__init__(
+ file_name=None, # this seems not important too.
+ url=url,
+ root=root,
+ AtomicData_options={}, # we do not pass anything here.
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ def get_data(self):
+ all_data = []
+ for subdata in self.raw_data:
+ # the type_mapper here is loaded in PyG `dataset` type as `transform` attritube
+ # so the OrbitalMapper can be accessed by self.transform here
+ subdata_list = subdata.toAtomicDataList(self.transform)
+ all_data += subdata_list
+ return all_data
+
+ @property
+ def raw_file_names(self):
+ # TODO: this is not implemented.
+ return "Null"
+
+ @property
+ def raw_dir(self):
+ # TODO: this is not implemented.
+ return self.root
+
+ def E3statistics(self, decay=False):
+ assert self.transform is not None
+ idp = self.transform
+
+ if self.data[AtomicDataDict.EDGE_FEATURES_KEY].abs().sum() < 1e-7:
+ return None
+
+ typed_dataset = idp(self.data.clone().to_dict())
+ e3h = E3Hamiltonian(basis=idp.basis, decompose=True)
+ with torch.no_grad():
+ typed_dataset = e3h(typed_dataset)
+
+ stats = {}
+ stats["node"] = self._E3nodespecies_stat(typed_dataset=typed_dataset)
+ stats["edge"] = self._E3edgespecies_stat(typed_dataset=typed_dataset, decay=decay)
+
+ return stats
+
+ def _E3edgespecies_stat(self, typed_dataset, decay):
+ # we get the bond type marked dataset first
+ idp = self.transform
+ typed_dataset = typed_dataset
+
+ idp.get_irreps(no_parity=False)
+ irrep_slices = idp.orbpair_irreps.slices()
+
+ features = typed_dataset["edge_features"]
+ hopping_block_mask = idp.mask_to_erme[typed_dataset["edge_type"].flatten()]
+ typed_hopping = {}
+ for bt, tp in idp.bond_to_type.items():
+ hopping_tp_mask = hopping_block_mask[typed_dataset["edge_type"].flatten().eq(tp)]
+ hopping_tp = features[typed_dataset["edge_type"].flatten().eq(tp)]
+ filtered_vecs = torch.where(hopping_tp_mask, hopping_tp, torch.tensor(float('nan')))
+ typed_hopping[bt] = filtered_vecs
+
+ sorted_irreps = idp.orbpair_irreps.sort()[0].simplify()
+ n_scalar = sorted_irreps[0].mul if sorted_irreps[0].ir.l == 0 else 0
+
+ # calculate norm & mean
+ typed_norm = {}
+ typed_norm_ave = torch.ones(len(idp.bond_to_type), idp.orbpair_irreps.num_irreps)
+ typed_norm_std = torch.zeros(len(idp.bond_to_type), idp.orbpair_irreps.num_irreps)
+ typed_scalar_ave = torch.ones(len(idp.bond_to_type), n_scalar)
+ typed_scalar_std = torch.zeros(len(idp.bond_to_type), n_scalar)
+ for bt, tp in idp.bond_to_type.items():
+ norms_per_irrep = []
+ count_scalar = 0
+ for ir, s in enumerate(irrep_slices):
+ sub_tensor = typed_hopping[bt][:, s]
+ # dump the nan blocks here
+ if sub_tensor.shape[-1] == 1:
+ count_scalar += 1
+ if not torch.isnan(sub_tensor).all():
+ # update the mean and ave
+ norms = torch.norm(sub_tensor, p=2, dim=1) # shape: [n_edge]
+ if sub_tensor.shape[-1] == 1:
+ # it's a scalar
+ typed_scalar_ave[tp][count_scalar-1] = sub_tensor.mean()
+ typed_scalar_std[tp][count_scalar-1] = sub_tensor.std()
+ typed_norm_ave[tp][ir] = norms.mean()
+ typed_norm_std[tp][ir] = norms.std()
+ else:
+ norms = torch.ones_like(sub_tensor[:, 0])
+
+ if decay:
+ norms_per_irrep.append(norms)
+
+ assert count_scalar <= n_scalar
+ # shape of typed_norm: (n_irreps, n_edges)
+
+ if decay:
+ typed_norm[bt] = torch.stack(norms_per_irrep)
+
+ edge_stats = {
+ "norm_ave": typed_norm_ave,
+ "norm_std": typed_norm_std,
+ "scalar_ave": typed_scalar_ave,
+ "scalar_std": typed_scalar_std,
+ }
+
+ if decay:
+ typed_dataset = with_edge_vectors(typed_dataset)
+ decay = {}
+ for bt, tp in idp.bond_to_type.items():
+ decay_bt = {}
+ lengths_bt = typed_dataset["edge_lengths"][typed_dataset["edge_type"].flatten().eq(tp)]
+ sorted_lengths, indices = lengths_bt.sort() # from small to large
+ # sort the norms by irrep l
+ sorted_norms = typed_norm[bt][idp.orbpair_irreps.sort().inv, :]
+ # sort the norms by edge length
+ sorted_norms = sorted_norms[:, indices]
+ decay_bt["edge_length"] = sorted_lengths
+ decay_bt["norm_decay"] = sorted_norms
+ decay[bt] = decay_bt
+
+ edge_stats["decay"] = decay
+
+ return edge_stats
+
+ def _E3nodespecies_stat(self, typed_dataset):
+ # we get the type marked dataset first
+ idp = self.transform
+ typed_dataset = typed_dataset
+
+ idp.get_irreps(no_parity=False)
+ irrep_slices = idp.orbpair_irreps.slices()
+
+ sorted_irreps = idp.orbpair_irreps.sort()[0].simplify()
+ n_scalar = sorted_irreps[0].mul if sorted_irreps[0].ir.l == 0 else 0
+
+ features = typed_dataset["node_features"]
+ onsite_block_mask = idp.mask_to_nrme[typed_dataset["atom_types"].flatten()]
+ typed_onsite = {}
+ for at, tp in idp.chemical_symbol_to_type.items():
+ onsite_tp_mask = onsite_block_mask[typed_dataset["atom_types"].flatten().eq(tp)]
+ onsite_tp = features[typed_dataset["atom_types"].flatten().eq(tp)]
+ filtered_vecs = torch.where(onsite_tp_mask, onsite_tp, torch.tensor(float('nan')))
+ typed_onsite[at] = filtered_vecs
+
+ # calculate norm & mean
+ typed_norm_ave = torch.ones(len(idp.chemical_symbol_to_type), idp.orbpair_irreps.num_irreps)
+ typed_norm_std = torch.zeros(len(idp.chemical_symbol_to_type), idp.orbpair_irreps.num_irreps)
+ typed_scalar_ave = torch.ones(len(idp.chemical_symbol_to_type), n_scalar)
+ typed_scalar_std = torch.zeros(len(idp.chemical_symbol_to_type), n_scalar)
+ for at, tp in idp.chemical_symbol_to_type.items():
+ count_scalar = 0
+ for ir, s in enumerate(irrep_slices):
+ sub_tensor = typed_onsite[at][:, s]
+ # dump the nan blocks here
+ if sub_tensor.shape[-1] == 1:
+ count_scalar += 1
+ if not torch.isnan(sub_tensor).all():
+
+ norms = torch.norm(sub_tensor, p=2, dim=1)
+ typed_norm_ave[tp][ir] = norms.mean()
+ typed_norm_std[tp][ir] = norms.std()
+ if s.stop - s.start == 1:
+ # it's a scalar
+ typed_scalar_ave[tp][count_scalar-1] = sub_tensor.mean()
+ typed_scalar_std[tp][count_scalar-1] = sub_tensor.std()
+
+ edge_stats = {
+ "norm_ave": typed_norm_ave,
+ "norm_std": typed_norm_std,
+ "scalar_ave": typed_scalar_ave,
+ "scalar_std": typed_scalar_std,
+ }
+
+ return edge_stats
\ No newline at end of file
diff --git a/dptb/data/dataset/_hdf5_dataset.py b/dptb/data/dataset/_hdf5_dataset.py
new file mode 100644
index 00000000..5fce39e2
--- /dev/null
+++ b/dptb/data/dataset/_hdf5_dataset.py
@@ -0,0 +1,171 @@
+from typing import Dict, Any, List, Callable, Union, Optional
+from collections import defaultdict
+import numpy as np
+
+import torch
+
+from .. import (
+ AtomicData,
+ AtomicDataDict,
+)
+from ..transforms import TypeMapper
+from ._base_datasets import AtomicDataset
+
+
+class HDF5Dataset(AtomicDataset):
+ """A dataset that loads data from a HDF5 file.
+
+ This class is useful for very large datasets that cannot fit in memory. It
+ efficiently loads data from disk as needed without everything needing to be
+ in memory at once.
+
+ To use this, ``file_name`` should point to the HDF5 file, or alternatively a
+ semicolon separated list of multiple files. Each group in the file contains
+ samples that all have the same number of atoms. Typically there is one
+ group for each unique number of atoms, but that is not required. Each group
+ should contain arrays whose length equals the number of samples, one for each
+ type of data. The names of the arrays can be specified with ``key_mapping``.
+
+ Args:
+ key_mapping (Dict[str, str]): mapping of array names in the HDF5 file to ``AtomicData`` keys
+ file_name (string): a semicolon separated list of HDF5 files.
+ """
+
+ def __init__(
+ self,
+ root: str,
+ key_mapping: Dict[str, str] = {
+ "pos": AtomicDataDict.POSITIONS_KEY,
+ "energy": AtomicDataDict.TOTAL_ENERGY_KEY,
+ "forces": AtomicDataDict.FORCE_KEY,
+ "atomic_numbers": AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ "types": AtomicDataDict.ATOM_TYPE_KEY,
+ },
+ file_name: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ type_mapper: Optional[TypeMapper] = None,
+ ):
+ super().__init__(root=root, type_mapper=type_mapper)
+ self.key_mapping = key_mapping
+ self.key_list = list(key_mapping.keys())
+ self.value_list = list(key_mapping.values())
+ self.file_name = file_name
+ self.r_max = AtomicData_options["r_max"]
+ self.index = None
+ self.num_frames = 0
+ import h5py
+
+ files = [h5py.File(f, "r") for f in self.file_name.split(";")]
+ for file in files:
+ for group_name in file:
+ for key in self.key_list:
+ if key in file[group_name]:
+ self.num_frames += len(file[group_name][key])
+ break
+ file.close()
+
+ def setup_index(self):
+ import h5py
+
+ files = [h5py.File(f, "r") for f in self.file_name.split(";")]
+ self.has_forces = False
+ self.index = []
+ for file in files:
+ for group_name in file:
+ group = file[group_name]
+ values = [None] * len(self.key_list)
+ samples = 0
+ for i, key in enumerate(self.key_list):
+ if key in group:
+ values[i] = group[key]
+ samples = len(values[i])
+ for i in range(samples):
+ self.index.append(tuple(values + [i]))
+
+ def len(self) -> int:
+ return self.num_frames
+
+ def get(self, idx: int) -> AtomicData:
+ if self.index is None:
+ self.setup_index()
+ data = self.index[idx]
+ i = data[-1]
+ args = {"r_max": self.r_max}
+ for j, value in enumerate(self.value_list):
+ if data[j] is not None:
+ args[value] = data[j][i]
+ return AtomicData.from_points(**args)
+
+ def statistics(
+ self,
+ fields: List[Union[str, Callable]],
+ modes: List[str],
+ stride: int = 1,
+ unbiased: bool = True,
+ kwargs: Optional[Dict[str, dict]] = {},
+ ) -> List[tuple]:
+ assert len(modes) == len(fields)
+ # TODO: use RunningStats
+ if len(fields) == 0:
+ return []
+ if self.index is None:
+ self.setup_index()
+ results = []
+ indices = self.indices()
+ if stride != 1:
+ indices = list(indices)[::stride]
+ for field, mode in zip(fields, modes):
+ count = 0
+ if mode == "rms":
+ total = 0.0
+ elif mode in ("mean_std", "per_atom_mean_std"):
+ total = [0.0, 0.0]
+ elif mode == "count":
+ counts = defaultdict(int)
+ else:
+ raise NotImplementedError(f"Analysis mode '{mode}' is not implemented")
+ for index in indices:
+ data = self.index[index]
+ i = data[-1]
+ if field in self.value_list:
+ values = data[self.value_list.index(field)][i]
+ elif callable(field):
+ values, _ = field(self.get(index))
+ values = np.asarray(values)
+ else:
+ raise RuntimeError(
+ f"The field key `{field}` is not present in this dataset"
+ )
+ length = len(values.flatten())
+ if length == 1:
+ values = np.array([values])
+ if mode == "rms":
+ total += np.sum(values * values)
+ count += length
+ elif mode == "count":
+ for v in values:
+ counts[v] += 1
+ else:
+ if mode == "per_atom_mean_std":
+ values /= len(data[0][i])
+ for v in values:
+ count += 1
+ delta1 = v - total[0]
+ total[0] += delta1 / count
+ delta2 = v - total[0]
+ total[1] += delta1 * delta2
+ if mode == "rms":
+ results.append(torch.tensor((np.sqrt(total / count),)))
+ elif mode == "count":
+ values = sorted(counts.keys())
+ results.append(
+ (torch.tensor(values), torch.tensor([counts[v] for v in values]))
+ )
+ else:
+ results.append(
+ (
+ torch.tensor(total[0]),
+ torch.tensor(np.sqrt(total[1] / (count - 1))),
+ )
+ )
+ return results
diff --git a/dptb/data/dataset/_npz_dataset.py b/dptb/data/dataset/_npz_dataset.py
new file mode 100644
index 00000000..84080604
--- /dev/null
+++ b/dptb/data/dataset/_npz_dataset.py
@@ -0,0 +1,143 @@
+import numpy as np
+from os.path import dirname, basename, abspath
+from typing import Dict, Any, List, Optional
+
+
+from .. import AtomicDataDict, _LONG_FIELDS, _NODE_FIELDS, _GRAPH_FIELDS
+from ..transforms import TypeMapper
+from ._base_datasets import AtomicInMemoryDataset
+
+
+class NpzDataset(AtomicInMemoryDataset):
+ """Load data from an npz file.
+
+ To avoid loading unneeded data, keys are ignored by default unless they are in ``key_mapping``, ``include_keys``,
+ or ``npz_fixed_fields_keys``.
+
+ Args:
+ key_mapping (Dict[str, str]): mapping of npz keys to ``AtomicData`` keys. Optional
+ include_keys (list): the attributes to be processed and stored. Optional
+ npz_fixed_field_keys: the attributes that only have one instance but apply to all frames. Optional
+ Note that the mapped keys (as determined by the _values_ in ``key_mapping``) should be used in
+ ``npz_fixed_field_keys``, not the original npz keys from before mapping. If an npz key is not
+ present in ``key_mapping``, it is mapped to itself, and this point is not relevant.
+
+ Example: Given a npz file with 10 configurations, each with 14 atoms.
+
+ position: (10, 14, 3)
+ force: (10, 14, 3)
+ energy: (10,)
+ Z: (14)
+ user_label1: (10) # per config
+ user_label2: (10, 14, 3) # per atom
+
+ The input yaml should be
+
+ ```yaml
+ dataset: npz
+ dataset_file_name: example.npz
+ include_keys:
+ - user_label1
+ - user_label2
+ npz_fixed_field_keys:
+ - cell
+ - atomic_numbers
+ key_mapping:
+ position: pos
+ force: forces
+ energy: total_energy
+ Z: atomic_numbers
+ graph_fields:
+ - user_label1
+ node_fields:
+ - user_label2
+ ```
+
+ """
+
+ def __init__(
+ self,
+ root: str,
+ key_mapping: Dict[str, str] = {
+ "positions": AtomicDataDict.POSITIONS_KEY,
+ "energy": AtomicDataDict.TOTAL_ENERGY_KEY,
+ "force": AtomicDataDict.FORCE_KEY,
+ "forces": AtomicDataDict.FORCE_KEY,
+ "Z": AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ "atomic_number": AtomicDataDict.ATOMIC_NUMBERS_KEY,
+ },
+ include_keys: List[str] = [],
+ npz_fixed_field_keys: List[str] = [],
+ file_name: Optional[str] = None,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: TypeMapper = None,
+ ):
+ self.key_mapping = key_mapping
+ self.npz_fixed_field_keys = npz_fixed_field_keys
+ self.include_keys = include_keys
+
+ super().__init__(
+ file_name=file_name,
+ url=url,
+ root=root,
+ AtomicData_options=AtomicData_options,
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ @property
+ def raw_file_names(self):
+ return [basename(self.file_name)]
+
+ @property
+ def raw_dir(self):
+ return dirname(abspath(self.file_name))
+
+ def get_data(self):
+ # get data returns either a list of AtomicData class or a data dict
+
+ data = np.load(self.raw_dir + "/" + self.raw_file_names[0], allow_pickle=True)
+
+ # only the keys explicitly mentioned in the yaml file will be parsed
+ keys = set(list(self.key_mapping.keys()))
+
+ keys.update(self.npz_fixed_field_keys)
+ keys.update(self.include_keys)
+ keys = keys.intersection(set(list(data.keys())))
+
+ mapped = {self.key_mapping.get(k, k): data[k] for k in keys}
+
+ for intkey in _LONG_FIELDS:
+ if intkey in mapped:
+ mapped[intkey] = mapped[intkey].astype(np.int64)
+
+ fields = {k: v for k, v in mapped.items() if k not in self.npz_fixed_field_keys}
+ num_examples, num_atoms, n_dim = fields[AtomicDataDict.POSITIONS_KEY].shape
+ assert n_dim == 3
+
+ # now we replicate and add the fixed fields:
+ for fixed_field in self.npz_fixed_field_keys:
+ orig = mapped[fixed_field]
+ if fixed_field in _NODE_FIELDS:
+ assert orig.ndim >= 1 # [n_atom, feature_dims]
+ assert orig.shape[0] == num_atoms
+ replicated = np.expand_dims(orig, 0)
+ replicated = np.tile(
+ replicated,
+ (num_examples,) + (1,) * len(replicated.shape[1:]),
+ ) # [n_example, n_atom, feature_dims]
+ elif fixed_field in _GRAPH_FIELDS:
+ # orig is [feature_dims]
+ replicated = np.expand_dims(orig, 0)
+ replicated = np.tile(
+ replicated,
+ (num_examples,) + (1,) * len(replicated.shape[1:]),
+ ) # [n_example, feature_dims]
+ else:
+ raise KeyError(
+ f"npz_fixed_field_keys contains `{fixed_field}`, but it isn't registered as a node or graph field"
+ )
+ fields[fixed_field] = replicated
+ return fields
diff --git a/dptb/nnet/__init__.py b/dptb/data/interfaces/__init__.py
similarity index 100%
rename from dptb/nnet/__init__.py
rename to dptb/data/interfaces/__init__.py
diff --git a/dptb/data/interfaces/abacus.py b/dptb/data/interfaces/abacus.py
new file mode 100644
index 00000000..6123ee5d
--- /dev/null
+++ b/dptb/data/interfaces/abacus.py
@@ -0,0 +1,378 @@
+# Modified from script 'abasus_get_data.py' for interface from ABACUS to DeepH-pack
+# To use this script, please add 'out_mat_hs2 1' in ABACUS INPUT File
+# Current version is capable of coping with f-orbitals
+
+import os
+import glob
+import json
+import re
+from collections import Counter
+from tqdm import tqdm
+
+import numpy as np
+from scipy.sparse import csr_matrix
+from scipy.linalg import block_diag
+import h5py
+import ase
+
+orbitalId = {0:'s',1:'p',2:'d',3:'f'}
+Bohr2Ang = 0.529177249
+
+
+class OrbAbacus2DeepTB:
+ def __init__(self):
+ self.Us_abacus2deeptb = {}
+ self.Us_abacus2deeptb[0] = np.eye(1)
+ self.Us_abacus2deeptb[1] = np.eye(3)[[2, 0, 1]] # 0, 1, -1 -> -1, 0, 1
+ self.Us_abacus2deeptb[2] = np.eye(5)[[4, 2, 0, 1, 3]] # 0, 1, -1, 2, -2 -> -2, -1, 0, 1, 2
+ self.Us_abacus2deeptb[3] = np.eye(7)[[6, 4, 2, 0, 1, 3, 5]] # -3,-2,-1,0,1,2,3
+
+ minus_dict = {
+ 1: [0, 2],
+ 2: [1, 3],
+ 3: [0, 2, 4, 6],
+ }
+
+ for k, v in minus_dict.items():
+ self.Us_abacus2deeptb[k][v] *= -1 # add phase (-1)^m
+
+ def get_U(self, l):
+ if l > 3:
+ raise NotImplementedError("Only support l = s, p, d, f")
+ return self.Us_abacus2deeptb[l]
+
+ def transform(self, mat, l_lefts, l_rights):
+ block_lefts = block_diag(*[self.get_U(l_left) for l_left in l_lefts])
+ block_rights = block_diag(*[self.get_U(l_right) for l_right in l_rights])
+ return block_lefts @ mat @ block_rights.T
+
+def recursive_parse(input_path,
+ preprocess_dir,
+ data_name="OUT.ABACUS",
+ only_overlap=False,
+ parse_Hamiltonian=False,
+ add_overlap=False,
+ parse_eigenvalues=False,
+ prefix="data"):
+ """
+ Parse ABACUS single point SCF calculation outputs.
+ Input:
+ `input_dir`: target dictionary(ies) containing "OUT.ABACUS" folder.
+ can be wildcard characters or a string list.
+ `preprocess_dir`: output dictionary of all processed data files.
+ `data_name`: output dictionary name of ABACUS, by default "OUT.ABACUS".
+ `only_overlap`: usually `False`.
+ set to `True` if the calculation job is getting overlap matrix ONLY.
+ `parse_Hamiltonian`: determine whether parsing the Hamiltonian `.csr` file or not.
+ `add_overlap`: determine whether parsing the overlap `.csr` file or not.
+ `parse_Hamiltonian` must be true to add overlap.
+ `parse_eigenvalues`: determine whether parsing `kpoints.dat` and `BAND_1.dat` or not.
+ that is, the k-points will always be loaded with bands.
+ `prefix`: prefix of the processed data folders' names.
+ """
+ if isinstance(input_path, list) and all(isinstance(item, str) for item in input_path):
+ input_path = input_path
+ else:
+ input_path = glob.glob(input_path)
+ preprocess_dir = os.path.abspath(preprocess_dir)
+ os.makedirs(preprocess_dir, exist_ok=True)
+ # h5file_names = []
+
+ folders = [item for item in input_path if os.path.isdir(item)]
+
+ with tqdm(total=len(folders)) as pbar:
+ for index, folder in enumerate(folders):
+ datafiles = os.listdir(folder)
+ if data_name in datafiles:
+ # The follwing `if` block is used by us only.
+ if os.path.exists(os.path.join(folder, data_name, "hscsr.tgz")):
+ os.system("cd "+os.path.join(folder, data_name) + " && tar -zxvf hscsr.tgz && mv OUT.ABACUS/* ./")
+ try:
+ _abacus_parse(folder,
+ os.path.join(preprocess_dir, f"{prefix}.{index}"),
+ data_name,
+ only_S=only_overlap,
+ get_Ham=parse_Hamiltonian,
+ add_overlap=add_overlap,
+ get_eigenvalues=parse_eigenvalues)
+ #h5file_names.append(os.path.join(file, "AtomicData.h5"))
+ pbar.update(1)
+ except Exception as e:
+ print(f"Error in {folder}/{data_name}: {e}")
+ continue
+ #return h5file_names
+
+def _abacus_parse(input_path,
+ output_path,
+ data_name,
+ only_S=False,
+ get_Ham=False,
+ add_overlap=False,
+ get_eigenvalues=False):
+
+ input_path = os.path.abspath(input_path)
+ output_path = os.path.abspath(output_path)
+ os.makedirs(output_path, exist_ok=True)
+
+ def find_target_line(f, target):
+ line = f.readline()
+ while line:
+ if target in line:
+ return line
+ line = f.readline()
+ return None
+ if only_S:
+ log_file_name = "running_get_S.log"
+ else:
+ log_file_name = "running_scf.log"
+
+ with open(os.path.join(input_path, data_name, log_file_name), 'r') as f_chk:
+ lines = f_chk.readlines()
+ if not lines or " Total Time :" not in lines[-1]:
+ raise ValueError(f"Job is not normal ending!")
+
+ with open(os.path.join(input_path, data_name, log_file_name), 'r') as f:
+ f.readline()
+ line = f.readline()
+ # assert "WELCOME TO ABACUS" in line
+ assert find_target_line(f, "READING UNITCELL INFORMATION") is not None, 'Cannot find "READING UNITCELL INFORMATION" in log file'
+ num_atom_type = int(f.readline().split()[-1])
+
+ assert find_target_line(f, "lattice constant (Bohr)") is not None
+ lattice_constant = float(f.readline().split()[-1]) # unit is Angstrom, didn't read (Bohr) here.
+
+ site_norbits_dict = {}
+ orbital_types_dict = {}
+ for index_type in range(num_atom_type):
+ tmp = find_target_line(f, "READING ATOM TYPE")
+ assert tmp is not None, 'Cannot find "ATOM TYPE" in log file'
+ assert tmp.split()[-1] == str(index_type + 1)
+ if tmp is None:
+ raise Exception(f"Cannot find ATOM {index_type} in {log_file_name}")
+
+ line = f.readline()
+ assert "atom label =" in line
+ atom_label = line.split()[-1]
+ assert atom_label in ase.data.atomic_numbers, "Atom label should be in periodic table"
+ atom_type = ase.data.atomic_numbers[atom_label]
+
+ current_site_norbits = 0
+ current_orbital_types = []
+ while True:
+ line = f.readline()
+ if "number of zeta" in line:
+ tmp = line.split()
+ L = int(tmp[0][2:-1])
+ num_L = int(tmp[-1])
+ current_site_norbits += (2 * L + 1) * num_L
+ current_orbital_types.extend([L] * num_L)
+ else:
+ break
+ site_norbits_dict[atom_type] = current_site_norbits
+ orbital_types_dict[atom_type] = current_orbital_types
+
+ #print(orbital_types_dict)
+
+ line = find_target_line(f, "TOTAL ATOM NUMBER")
+ assert line is not None, 'Cannot find "TOTAL ATOM NUMBER" in log file'
+ nsites = int(line.split()[-1])
+
+ line = find_target_line(f, " COORDINATES")
+ assert line is not None, 'Cannot find "DIRECT COORDINATES" or "CARTESIAN COORDINATES" in log file'
+ if "DIRECT" in line:
+ coords_type = "direct"
+ elif "CARTESIAN" in line:
+ coords_type = "cartesian"
+ else:
+ raise ValueError('Cannot find "DIRECT COORDINATES" or "CARTESIAN COORDINATES" in log file')
+
+ assert "atom" in f.readline()
+ frac_coords = np.zeros((nsites, 3))
+ site_norbits = np.zeros(nsites, dtype=int)
+ element = np.zeros(nsites, dtype=int)
+ for index_site in range(nsites):
+ line = f.readline()
+ tmp = line.split()
+ assert "tau" in tmp[0]
+ atom_label = ''.join(re.findall(r'[A-Za-z]', tmp[0][5:]))
+ assert atom_label in ase.data.atomic_numbers, "Atom label should be in periodic table"
+ element[index_site] = ase.data.atomic_numbers[atom_label]
+ site_norbits[index_site] = site_norbits_dict[element[index_site]]
+ frac_coords[index_site, :] = np.array(tmp[1:4])
+ norbits = int(np.sum(site_norbits))
+ site_norbits_cumsum = np.cumsum(site_norbits)
+
+ assert find_target_line(f, "Lattice vectors: (Cartesian coordinate: in unit of a_0)") is not None
+ lattice = np.zeros((3, 3))
+ for index_lat in range(3):
+ lattice[index_lat, :] = np.array(f.readline().split())
+ if coords_type == "cartesian":
+ frac_coords = frac_coords @ np.matrix(lattice).I # get frac_coords anyway
+ lattice = lattice * lattice_constant
+
+ if only_S:
+ spinful = False
+ else:
+ line = find_target_line(f, "NSPIN")
+ assert line is not None, 'Cannot find "NSPIN" in log file'
+ if "NSPIN == 1" in line:
+ spinful = False
+ elif "NSPIN == 4" in line:
+ spinful = True
+ else:
+ raise ValueError(f'{line} is not supported')
+
+ np.savetxt(os.path.join(output_path, "cell.dat"), lattice)
+ np.savetxt(os.path.join(output_path, "rcell.dat"), np.linalg.inv(lattice) * 2 * np.pi)
+ cart_coords = frac_coords @ lattice
+ np.savetxt(os.path.join(output_path, "positions.dat").format(output_path), cart_coords)
+ np.savetxt(os.path.join(output_path, "atomic_numbers.dat"), element, fmt='%d')
+ #info = {'nsites' : nsites, 'isorthogonal': False, 'isspinful': spinful, 'norbits': norbits}
+ #with open('{}/info.json'.format(output_path), 'w') as info_f:
+ # json.dump(info, info_f)
+ with open(os.path.join(output_path, "basis.dat"), 'w') as f:
+ for atomic_number in element:
+ counter = Counter(orbital_types_dict[atomic_number])
+ num_orbs = [counter[i] for i in range(4)] # s, p, d, f
+ for index_l, l in enumerate(num_orbs):
+ if l == 0: # no this orbit
+ continue
+ if index_l == 0:
+ f.write(f"{l}{orbitalId[index_l]}")
+ else:
+ f.write(f"{l}{orbitalId[index_l]}")
+ f.write('\n')
+ atomic_basis = {}
+ for atomic_number, orbitals in orbital_types_dict.items():
+ atomic_basis[ase.data.chemical_symbols[atomic_number]] = orbitals
+
+ if get_Ham:
+ U_orbital = OrbAbacus2DeepTB()
+ def parse_matrix(matrix_path, factor, spinful=False):
+ matrix_dict = dict()
+ with open(matrix_path, 'r') as f:
+ line = f.readline() # read "Matrix Dimension of ..."
+ if not "Matrix Dimension of" in line:
+ line = f.readline() # ABACUS >= 3.0
+ assert "Matrix Dimension of" in line
+ f.readline() # read "Matrix number of ..."
+ norbits = int(line.split()[-1])
+ for line in f:
+ line1 = line.split()
+ if len(line1) == 0:
+ break
+ num_element = int(line1[3])
+ if num_element != 0:
+ R_cur = np.array(line1[:3]).astype(int)
+ line2 = f.readline().split()
+ line3 = f.readline().split()
+ line4 = f.readline().split()
+ if not spinful:
+ hamiltonian_cur = csr_matrix((np.array(line2).astype(float), np.array(line3).astype(int),
+ np.array(line4).astype(int)), shape=(norbits, norbits)).toarray()
+ else:
+ line2 = np.char.replace(line2, '(', '')
+ line2 = np.char.replace(line2, ')', 'j')
+ line2 = np.char.replace(line2, ',', '+')
+ line2 = np.char.replace(line2, '+-', '-')
+ hamiltonian_cur = csr_matrix((np.array(line2).astype(np.complex128), np.array(line3).astype(int),
+ np.array(line4).astype(int)), shape=(norbits, norbits)).toarray()
+ for index_site_i in range(nsites):
+ for index_site_j in range(nsites):
+ key_str = f"{index_site_i + 1}_{index_site_j + 1}_{R_cur[0]}_{R_cur[1]}_{R_cur[2]}"
+ mat = hamiltonian_cur[(site_norbits_cumsum[index_site_i]
+ - site_norbits[index_site_i]) * (1 + spinful):
+ site_norbits_cumsum[index_site_i] * (1 + spinful),
+ (site_norbits_cumsum[index_site_j] - site_norbits[index_site_j]) * (1 + spinful):
+ site_norbits_cumsum[index_site_j] * (1 + spinful)]
+ if abs(mat).max() < 1e-10:
+ continue
+ if not spinful:
+ mat = U_orbital.transform(mat, orbital_types_dict[element[index_site_i]],
+ orbital_types_dict[element[index_site_j]])
+ else:
+ mat = mat.reshape((site_norbits[index_site_i], 2, site_norbits[index_site_j], 2))
+ mat = mat.transpose((1, 0, 3, 2)).reshape((2 * site_norbits[index_site_i],
+ 2 * site_norbits[index_site_j]))
+ mat = U_orbital.transform(mat, orbital_types_dict[element[index_site_i]] * 2,
+ orbital_types_dict[element[index_site_j]] * 2)
+ matrix_dict[key_str] = mat * factor
+ return matrix_dict, norbits
+
+ if only_S:
+ overlap_dict, tmp = parse_matrix(os.path.join(input_path, "SR.csr"), 1)
+ assert tmp == norbits
+ else:
+ hamiltonian_dict, tmp = parse_matrix(
+ os.path.join(input_path, data_name, "data-HR-sparse_SPIN0.csr"), 13.605698, # Ryd2eV
+ spinful=spinful)
+ assert tmp == norbits * (1 + spinful)
+ overlap_dict, tmp = parse_matrix(os.path.join(input_path, data_name, "data-SR-sparse_SPIN0.csr"), 1,
+ spinful=spinful)
+ assert tmp == norbits * (1 + spinful)
+ if spinful:
+ overlap_dict_spinless = {}
+ for k, v in overlap_dict.items():
+ overlap_dict_spinless[k] = v[:v.shape[0] // 2, :v.shape[1] // 2].real
+ overlap_dict_spinless, overlap_dict = overlap_dict, overlap_dict_spinless
+
+ if not only_S:
+ with h5py.File(os.path.join(output_path, "hamiltonians.h5"), 'w') as fid:
+ # creating a default group here adapting to the format used in DefaultDataset.
+ # by the way DefaultDataset loading h5 file, the index should be "1" here.
+ default_group = fid.create_group("1")
+ for key_str, value in hamiltonian_dict.items():
+ default_group[key_str] = value
+ if add_overlap:
+ with h5py.File(os.path.join(output_path, "overlaps.h5"), 'w') as fid:
+ default_group = fid.create_group("1")
+ for key_str, value in overlap_dict.items():
+ default_group[key_str] = value
+
+ if get_eigenvalues:
+ kpts = []
+ with open(os.path.join(input_path, data_name, "kpoints"), "r") as f:
+ nkstot = f.readline().strip().split()[-1]
+ f.readline()
+ for _ in range(int(nkstot)):
+ line = f.readline()
+ kpt = []
+ line = line.strip().split()
+ kpt.extend([float(line[1]), float(line[2]), float(line[3])])
+ kpts.append(kpt)
+ kpts = np.array(kpts)
+
+ with open(os.path.join(input_path, data_name, "BANDS_1.dat"), "r") as file:
+ band_lines = file.readlines()
+ band = []
+ for line in band_lines:
+ values = line.strip().split()
+ eigs = [float(value) for value in values[1:]]
+ band.append(eigs)
+ band = np.array(band)
+
+ assert len(band) == len(kpts)
+ np.save(os.path.join(output_path, "kpoints.npy"), kpts)
+ np.save(os.path.join(output_path, "eigenvalues.npy"), band)
+
+ #with h5py.File(os.path.join(output_path, "AtomicData.h5"), "w") as f:
+ # f["cell"] = lattice
+ # f["pos"] = cart_coords
+ # f["atomic_numbers"] = element
+ # basis = f.create_group("basis")
+ # for key, value in atomic_basis.items():
+ # basis[key] = value
+ # if get_Ham:
+ # f["hamiltonian_blocks"] = h5py.ExternalLink("hamiltonians.h5", "/")
+ # if add_overlap:
+ # f["overlap_blocks"] = h5py.ExternalLink("overlaps.h5", "/")
+ # # else:
+ # # f["overlap_blocks"] = False
+ # # else:
+ # # f["hamiltonian_blocks"] = False
+ # if get_eigenvalues:
+ # f["kpoints"] = kpts
+ # f["eigenvalues"] = band
+ # # else:
+ # # f["kpoint"] = False
+ # # f["eigenvalue"] = False
diff --git a/dptb/data/interfaces/ham_to_feature.py b/dptb/data/interfaces/ham_to_feature.py
new file mode 100644
index 00000000..710f8b49
--- /dev/null
+++ b/dptb/data/interfaces/ham_to_feature.py
@@ -0,0 +1,209 @@
+from .. import _keys
+import ase
+import numpy as np
+import torch
+import re
+import e3nn.o3 as o3
+import h5py
+import logging
+from dptb.utils.constants import anglrMId
+
+log = logging.getLogger(__name__)
+
+def ham_block_to_feature(data, idp, Hamiltonian_blocks, overlap_blocks=False):
+ # Hamiltonian_blocks should be a h5 group in the current version
+ onsite_ham = []
+ edge_ham = []
+ if overlap_blocks:
+ edge_overlap = []
+
+ idp.get_orbital_maps()
+ idp.get_orbpair_maps()
+
+ atomic_numbers = data[_keys.ATOMIC_NUMBERS_KEY]
+
+ # onsite features
+ for atom in range(len(atomic_numbers)):
+ block_index = '_'.join(map(str, map(int, [atom+1, atom+1] + list([0, 0, 0]))))
+ try:
+ block = Hamiltonian_blocks[block_index]
+ except:
+ raise IndexError("Hamiltonian block for onsite not found, check Hamiltonian file.")
+
+ symbol = ase.data.chemical_symbols[atomic_numbers[atom]]
+ basis_list = idp.basis[symbol]
+ onsite_out = np.zeros(idp.reduced_matrix_element)
+
+ for index, basis_i in enumerate(basis_list):
+ slice_i = idp.orbital_maps[symbol][basis_i]
+ for basis_j in basis_list[index:]:
+ slice_j = idp.orbital_maps[symbol][basis_j]
+ block_ij = block[slice_i, slice_j]
+ full_basis_i = idp.basis_to_full_basis[symbol][basis_i]
+ full_basis_j = idp.basis_to_full_basis[symbol][basis_j]
+
+ # fill onsite vector
+ pair_ij = full_basis_i + "-" + full_basis_j
+ feature_slice = idp.orbpair_maps[pair_ij]
+ onsite_out[feature_slice] = block_ij.flatten()
+
+ onsite_ham.append(onsite_out)
+ #onsite_ham = np.array(onsite_ham)
+
+ # edge features
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_cell_shift = data[_keys.EDGE_CELL_SHIFT_KEY]
+
+ for atom_i, atom_j, R_shift in zip(edge_index[0], edge_index[1], edge_cell_shift):
+ block_index = '_'.join(map(str, map(int, [atom_i+1, atom_j+1] + list(R_shift))))
+ symbol_i = ase.data.chemical_symbols[atomic_numbers[atom_i]]
+ symbol_j = ase.data.chemical_symbols[atomic_numbers[atom_j]]
+
+ # try:
+ # block = Hamiltonian_blocks[block_index]
+ # if overlap_blocks:
+ # block_s = overlap_blocks[block_index]
+ # except:
+ # raise IndexError("Hamiltonian block for hopping not found, r_cut may be too big for input R.")
+
+ block = Hamiltonian_blocks.get(block_index, 0)
+ if overlap_blocks:
+ block_s = overlap_blocks.get(block_index, 0)
+ if block == 0:
+ block = torch.zeros(idp.norbs[symbol_i], idp.norbs[symbol_j])
+ log.warning("Hamiltonian block for hopping {} not found, r_cut may be too big for input R.".format(block_index))
+ if overlap_blocks:
+ if block_s == 0:
+ block_s = torch.zeros(idp.norbs[symbol_i], idp.norbs[symbol_j])
+ log.warning("Overlap block for hopping {} not found, r_cut may be too big for input R.".format(block_index))
+
+ assert block.shape == (idp.norbs[symbol_i], idp.norbs[symbol_j])
+
+
+ basis_i_list = idp.basis[symbol_i]
+ basis_j_list = idp.basis[symbol_j]
+ hopping_out = np.zeros(idp.reduced_matrix_element)
+ if overlap_blocks:
+ overlap_out = np.zeros(idp.reduced_matrix_element)
+
+ for basis_i in basis_i_list:
+ slice_i = idp.orbital_maps[symbol_i][basis_i]
+ for basis_j in basis_j_list:
+ slice_j = idp.orbital_maps[symbol_j][basis_j]
+ full_basis_i = idp.basis_to_full_basis[symbol_i][basis_i]
+ full_basis_j = idp.basis_to_full_basis[symbol_j][basis_j]
+ if idp.full_basis.index(full_basis_i) <= idp.full_basis.index(full_basis_j):
+ block_ij = block[slice_i, slice_j]
+ if overlap_blocks:
+ block_s_ij = block_s[slice_i, slice_j]
+
+ # fill hopping vector
+ pair_ij = full_basis_i + "-" + full_basis_j
+ feature_slice = idp.orbpair_maps[pair_ij]
+
+ hopping_out[feature_slice] = block_ij.flatten()
+ if overlap_blocks:
+ overlap_out[feature_slice] = block_s_ij.flatten()
+
+ edge_ham.append(hopping_out)
+ if overlap_blocks:
+ edge_overlap.append(overlap_out)
+
+ data[_keys.NODE_FEATURES_KEY] = torch.as_tensor(np.array(onsite_ham), dtype=torch.get_default_dtype())
+ data[_keys.EDGE_FEATURES_KEY] = torch.as_tensor(np.array(edge_ham), dtype=torch.get_default_dtype())
+ if overlap_blocks:
+ data[_keys.EDGE_OVERLAP_KEY] = torch.as_tensor(np.array(edge_overlap), dtype=torch.get_default_dtype())
+
+
+def openmx_to_deeptb(data, idp, openmx_hpath):
+ # Hamiltonian_blocks should be a h5 group in the current version
+ Us_openmx2wiki = {
+ "s": torch.eye(1).double(),
+ "p": torch.eye(3)[[1, 2, 0]].double(),
+ "d": torch.eye(5)[[2, 4, 0, 3, 1]].double(),
+ "f": torch.eye(7)[[6, 4, 2, 0, 1, 3, 5]].double()
+ }
+ # init_rot_mat
+ rot_blocks = {}
+ for asym, orbs in idp.basis.items():
+ b = [Us_openmx2wiki[re.findall(r"[A-Za-z]", orb)[0]] for orb in orbs]
+ rot_blocks[asym] = torch.block_diag(*b)
+
+
+ Hamiltonian_blocks = h5py.File(openmx_hpath, 'r')
+
+ onsite_ham = []
+ edge_ham = []
+
+ idp.get_orbital_maps()
+ idp.get_orbpair_maps()
+
+ atomic_numbers = data[_keys.ATOMIC_NUMBERS_KEY]
+
+ # onsite features
+ for atom in range(len(atomic_numbers)):
+ block_index = str([0, 0, 0, atom+1, atom+1])
+ try:
+ block = Hamiltonian_blocks[block_index][:]
+ except:
+ raise IndexError("Hamiltonian block for onsite not found, check Hamiltonian file.")
+
+
+ symbol = ase.data.chemical_symbols[atomic_numbers[atom]]
+ block = rot_blocks[symbol] @ block @ rot_blocks[symbol].T
+ basis_list = idp.basis[symbol]
+ onsite_out = np.zeros(idp.reduced_matrix_element)
+
+ for index, basis_i in enumerate(basis_list):
+ slice_i = idp.orbital_maps[symbol][basis_i]
+ for basis_j in basis_list[index:]:
+ slice_j = idp.orbital_maps[symbol][basis_j]
+ block_ij = block[slice_i, slice_j]
+ full_basis_i = idp.basis_to_full_basis[symbol][basis_i]
+ full_basis_j = idp.basis_to_full_basis[symbol][basis_j]
+
+ # fill onsite vector
+ pair_ij = full_basis_i + "-" + full_basis_j
+ feature_slice = idp.orbpair_maps[pair_ij]
+ onsite_out[feature_slice] = block_ij.flatten()
+
+ onsite_ham.append(onsite_out)
+ #onsite_ham = np.array(onsite_ham)
+
+ # edge features
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_cell_shift = data[_keys.EDGE_CELL_SHIFT_KEY]
+
+ for atom_i, atom_j, R_shift in zip(edge_index[0], edge_index[1], edge_cell_shift):
+ block_index = str(list(R_shift.int().numpy())+[int(atom_i)+1, int(atom_j)+1])
+ try:
+ block = Hamiltonian_blocks[block_index][:]
+ except:
+ raise IndexError("Hamiltonian block for hopping not found, r_cut may be too big for input R.")
+
+ symbol_i = ase.data.chemical_symbols[atomic_numbers[atom_i]]
+ symbol_j = ase.data.chemical_symbols[atomic_numbers[atom_j]]
+ block = rot_blocks[symbol_i] @ block @ rot_blocks[symbol_j].T
+ basis_i_list = idp.basis[symbol_i]
+ basis_j_list = idp.basis[symbol_j]
+ hopping_out = np.zeros(idp.reduced_matrix_element)
+
+ for basis_i in basis_i_list:
+ slice_i = idp.orbital_maps[symbol_i][basis_i]
+ for basis_j in basis_j_list:
+ slice_j = idp.orbital_maps[symbol_j][basis_j]
+ block_ij = block[slice_i, slice_j]
+ full_basis_i = idp.basis_to_full_basis[symbol_i][basis_i]
+ full_basis_j = idp.basis_to_full_basis[symbol_j][basis_j]
+
+ if idp.full_basis.index(full_basis_i) <= idp.full_basis.index(full_basis_j):
+ # fill hopping vector
+ pair_ij = full_basis_i + "-" + full_basis_j
+ feature_slice = idp.orbpair_maps[pair_ij]
+ hopping_out[feature_slice] = block_ij.flatten()
+
+ edge_ham.append(hopping_out)
+
+ data[_keys.NODE_FEATURES_KEY] = torch.as_tensor(np.array(onsite_ham), dtype=torch.get_default_dtype())
+ data[_keys.EDGE_FEATURES_KEY] = torch.as_tensor(np.array(edge_ham), dtype=torch.get_default_dtype())
+ Hamiltonian_blocks.close()
\ No newline at end of file
diff --git a/dptb/data/test_data.py b/dptb/data/test_data.py
new file mode 100644
index 00000000..7427cc4b
--- /dev/null
+++ b/dptb/data/test_data.py
@@ -0,0 +1,83 @@
+from typing import Optional, List, Dict, Any, Tuple
+import copy
+
+import numpy as np
+
+import ase
+import ase.build
+from ase.calculators.emt import EMT
+
+from dptb.data import AtomicInMemoryDataset, AtomicData
+from .transforms import TypeMapper
+
+
+class EMTTestDataset(AtomicInMemoryDataset):
+ """Test dataset with PBC based on the toy EMT potential included in ASE.
+
+ Randomly generates (in a reproducable manner) a basic bulk with added
+ Gaussian noise around equilibrium positions.
+
+ In ASE units (eV/Å).
+ """
+
+ def __init__(
+ self,
+ root: str,
+ supercell: Tuple[int, int, int] = (4, 4, 4),
+ sigma: float = 0.1,
+ element: str = "Cu",
+ num_frames: int = 10,
+ dataset_seed: int = 123456,
+ file_name: Optional[str] = None,
+ url: Optional[str] = None,
+ AtomicData_options: Dict[str, Any] = {},
+ include_frames: Optional[List[int]] = None,
+ type_mapper: TypeMapper = None,
+ ):
+ # Set properties for hashing
+ assert element in ("Cu", "Pd", "Au", "Pt", "Al", "Ni", "Ag")
+ self.element = element
+ self.sigma = sigma
+ self.supercell = tuple(supercell)
+ self.num_frames = num_frames
+ self.dataset_seed = dataset_seed
+
+ super().__init__(
+ file_name=file_name,
+ url=url,
+ root=root,
+ AtomicData_options=AtomicData_options,
+ include_frames=include_frames,
+ type_mapper=type_mapper,
+ )
+
+ @property
+ def raw_file_names(self):
+ return []
+
+ @property
+ def raw_dir(self):
+ return "raw"
+
+ def get_data(self):
+ rng = np.random.default_rng(self.dataset_seed)
+ base_atoms = ase.build.bulk(self.element, "fcc").repeat(self.supercell)
+ base_atoms.calc = EMT()
+ orig_pos = copy.deepcopy(base_atoms.positions)
+ datas = []
+ for _ in range(self.num_frames):
+ base_atoms.positions[:] = orig_pos
+ base_atoms.positions += rng.normal(
+ loc=0.0, scale=self.sigma, size=base_atoms.positions.shape
+ )
+
+ datas.append(
+ AtomicData.from_ase(
+ base_atoms.copy(),
+ forces=base_atoms.get_forces(),
+ total_energy=base_atoms.get_potential_energy(),
+ stress=base_atoms.get_stress(voigt=False),
+ **self.AtomicData_options
+ )
+ )
+ return datas
diff --git a/dptb/data/transforms.py b/dptb/data/transforms.py
new file mode 100644
index 00000000..4af4c4da
--- /dev/null
+++ b/dptb/data/transforms.py
@@ -0,0 +1,705 @@
+from typing import Dict, Optional, Union, List
+from dptb.data.AtomicDataDict import Type
+from dptb.utils.tools import get_uniq_symbol
+from dptb.utils.constants import anglrMId
+import re
+import warnings
+
+import torch
+
+import ase.data
+import e3nn.o3 as o3
+
+from dptb.data import AtomicData, AtomicDataDict
+
+
+class TypeMapper:
+ """Based on a configuration, map atomic numbers to types."""
+
+ num_types: int
+ chemical_symbol_to_type: Optional[Dict[str, int]]
+ type_to_chemical_symbol: Optional[Dict[int, str]]
+ type_names: List[str]
+ _min_Z: int
+
+ def __init__(
+ self,
+ type_names: Optional[List[str]] = None,
+ chemical_symbol_to_type: Optional[Dict[str, int]] = None,
+ type_to_chemical_symbol: Optional[Dict[int, str]] = None,
+ chemical_symbols: Optional[List[str]] = None,
+ device=torch.device("cpu"),
+ ):
+ self.device = device
+ if chemical_symbols is not None:
+ if chemical_symbol_to_type is not None:
+ raise ValueError(
+ "Cannot provide both `chemical_symbols` and `chemical_symbol_to_type`"
+ )
+ # repro old, sane NequIP behaviour
+ # checks also for validity of keys
+ atomic_nums = [ase.data.atomic_numbers[sym] for sym in chemical_symbols]
+ # https://stackoverflow.com/questions/29876580/how-to-sort-a-list-according-to-another-list-python
+ chemical_symbols = [
+ e[1] for e in sorted(zip(atomic_nums, chemical_symbols)) # low to high
+ ]
+ chemical_symbol_to_type = {k: i for i, k in enumerate(chemical_symbols)}
+ del chemical_symbols
+
+ if type_to_chemical_symbol is not None:
+ type_to_chemical_symbol = {
+ int(k): v for k, v in type_to_chemical_symbol.items()
+ }
+ assert all(
+ v in ase.data.chemical_symbols for v in type_to_chemical_symbol.values()
+ )
+
+ # Build from chem->type mapping, if provided
+ self.chemical_symbol_to_type = chemical_symbol_to_type
+ if self.chemical_symbol_to_type is not None:
+ # Validate
+ for sym, type in self.chemical_symbol_to_type.items():
+ assert sym in ase.data.atomic_numbers, f"Invalid chemical symbol {sym}"
+ assert 0 <= type, f"Invalid type number {type}"
+ assert set(self.chemical_symbol_to_type.values()) == set(
+ range(len(self.chemical_symbol_to_type))
+ )
+ if type_names is None:
+ # Make type_names
+ type_names = [None] * len(self.chemical_symbol_to_type)
+ for sym, type in self.chemical_symbol_to_type.items():
+ type_names[type] = sym
+ else:
+ # Make sure they agree on types
+ # We already checked that chem->type is contiguous,
+ # so enough to check length since type_names is a list
+ assert len(type_names) == len(self.chemical_symbol_to_type)
+ # Make mapper array
+ valid_atomic_numbers = [
+ ase.data.atomic_numbers[sym] for sym in self.chemical_symbol_to_type
+ ]
+ self._min_Z = min(valid_atomic_numbers)
+ self._max_Z = max(valid_atomic_numbers)
+ Z_to_index = torch.full(
+ size=(1 + self._max_Z - self._min_Z,), fill_value=-1, dtype=torch.long, device=device
+ )
+ for sym, type in self.chemical_symbol_to_type.items():
+ Z_to_index[ase.data.atomic_numbers[sym] - self._min_Z] = type
+ self._Z_to_index = Z_to_index
+ self._index_to_Z = torch.zeros(
+ size=(len(self.chemical_symbol_to_type),), dtype=torch.long, device=device
+ )
+ for sym, type_idx in self.chemical_symbol_to_type.items():
+ self._index_to_Z[type_idx] = ase.data.atomic_numbers[sym]
+ self._valid_set = set(valid_atomic_numbers)
+ true_type_to_chemical_symbol = {
+ type_id: sym for sym, type_id in self.chemical_symbol_to_type.items()
+ }
+ if type_to_chemical_symbol is not None:
+ assert type_to_chemical_symbol == true_type_to_chemical_symbol
+ else:
+ type_to_chemical_symbol = true_type_to_chemical_symbol
+
+ # check
+ if type_names is None:
+ raise ValueError(
+ "None of chemical_symbols, chemical_symbol_to_type, nor type_names was provided; exactly one is required"
+ )
+ # validate type names
+ assert all(
+ n.isalnum() for n in type_names
+ ), "Type names must contain only alphanumeric characters"
+ # Set to however many maps specified -- we already checked contiguous
+ self.num_types = len(type_names)
+ # Check type_names
+ self.type_names = type_names
+ self.type_to_chemical_symbol = type_to_chemical_symbol
+ if self.type_to_chemical_symbol is not None:
+ assert set(type_to_chemical_symbol.keys()) == set(range(self.num_types))
+
+ def __call__(
+ self, data: Union[AtomicDataDict.Type, AtomicData], types_required: bool = True
+ ) -> Union[AtomicDataDict.Type, AtomicData]:
+ if AtomicDataDict.ATOM_TYPE_KEY in data:
+ if AtomicDataDict.ATOMIC_NUMBERS_KEY in data:
+ warnings.warn(
+ "Data contained both ATOM_TYPE_KEY and ATOMIC_NUMBERS_KEY; ignoring ATOMIC_NUMBERS_KEY"
+ )
+ elif AtomicDataDict.ATOMIC_NUMBERS_KEY in data:
+ assert (
+ self.chemical_symbol_to_type is not None
+ ), "Atomic numbers provided but there is no chemical_symbols/chemical_symbol_to_type mapping!"
+ atomic_numbers = data[AtomicDataDict.ATOMIC_NUMBERS_KEY]
+ del data[AtomicDataDict.ATOMIC_NUMBERS_KEY]
+
+ data[AtomicDataDict.ATOM_TYPE_KEY] = self.transform(atomic_numbers)
+ else:
+ if types_required:
+ raise KeyError(
+ "Data doesn't contain any atom type information (ATOM_TYPE_KEY or ATOMIC_NUMBERS_KEY)"
+ )
+ return data
+
+ def transform(self, atomic_numbers):
+ """core function to transform an array to specie index list"""
+
+ if atomic_numbers.min() < self._min_Z or atomic_numbers.max() > self._max_Z:
+ bad_set = set(torch.unique(atomic_numbers).cpu().tolist()) - self._valid_set
+ raise ValueError(
+ f"Data included atomic numbers {bad_set} that are not part of the atomic number -> type mapping!"
+ )
+
+ return self._Z_to_index.to(device=atomic_numbers.device)[
+ atomic_numbers - self._min_Z
+ ]
+
+ def untransform(self, atom_types):
+ """Transform atom types back into atomic numbers"""
+ return self._index_to_Z[atom_types].to(device=atom_types.device)
+
+ @property
+ def has_chemical_symbols(self) -> bool:
+ return self.chemical_symbol_to_type is not None
+
+ @staticmethod
+ def format(
+ data: list, type_names: List[str], element_formatter: str = ".6f"
+ ) -> str:
+ """
+ Formats a list of data elements along with their type names.
+
+ Parameters:
+ data (list): The data elements to be formatted. This should be a list of numbers.
+ type_names (List[str]): The type names corresponding to the data elements. This should be a list of strings.
+ element_formatter (str, optional): The format in which the data elements should be displayed. Defaults to ".6f".
+
+ Returns:
+ str: A string representation of the data elements along with their type names.
+
+ Raises:
+ ValueError: If `data` is not None, not 0-dimensional, or not 1-dimensional with length equal to the length of `type_names`.
+
+ Example:
+ >>> data = [1.123456789, 2.987654321]
+ >>> type_names = ['Type1', 'Type2']
+ >>> print(TypeMapper.format(data, type_names))
+ [Type1: 1.123457, Type2: 2.987654]
+ """
+ data = torch.as_tensor(data) if data is not None else None
+ if data is None:
+ return f"[{', '.join(type_names)}: None]"
+ elif data.ndim == 0:
+ return (f"[{', '.join(type_names)}: {{:{element_formatter}}}]").format(data)
+ elif data.ndim == 1 and len(data) == len(type_names):
+ return (
+ "["
+ + ", ".join(
+ f"{{{i}[0]}}: {{{i}[1]:{element_formatter}}}"
+ for i in range(len(data))
+ )
+ + "]"
+ ).format(*zip(type_names, data))
+ else:
+ raise ValueError(
+ f"Don't know how to format data=`{data}` for types {type_names} with element_formatter=`{element_formatter}`"
+ )
+
+
+class BondMapper(TypeMapper):
+ def __init__(
+ self,
+ chemical_symbols: Optional[List[str]] = None,
+ chemical_symbols_to_type:Union[Dict[str, int], None]=None,
+ device=torch.device("cpu"),
+ ):
+ super(BondMapper, self).__init__(chemical_symbol_to_type=chemical_symbols_to_type, chemical_symbols=chemical_symbols, device=device)
+
+ self.bond_types = [None] * self.num_types ** 2
+ self.reduced_bond_types = [None] * ((self.num_types * (self.num_types + 1)) // 2)
+ self.bond_to_type = {}
+ self.type_to_bond = {}
+ self.reduced_bond_to_type = {}
+ self.type_to_reduced_bond = {}
+ for asym, ai in self.chemical_symbol_to_type.items():
+ for bsym, bi in self.chemical_symbol_to_type.items():
+ self.bond_types[ai * self.num_types + bi] = asym + "-" + bsym
+ if ai <= bi:
+ self.reduced_bond_types[(2*self.num_types-ai+1) * ai // 2 + bi-ai] = asym + "-" + bsym
+ for i, bt in enumerate(self.bond_types):
+ self.bond_to_type[bt] = i
+ self.type_to_bond[i] = bt
+ for i, bt in enumerate(self.reduced_bond_types):
+ self.reduced_bond_to_type[bt] = i
+ self.type_to_reduced_bond[i] = bt
+
+ ZZ_to_index = torch.full(
+ size=(len(self._Z_to_index), len(self._Z_to_index)), fill_value=-1, device=device, dtype=torch.long
+ )
+ ZZ_to_reduced_index = torch.full(
+ size=(len(self._Z_to_index), len(self._Z_to_index)), fill_value=-1, device=device, dtype=torch.long
+ )
+
+
+ for abond, aidx in self.bond_to_type.items(): # type_names has a ascending order according to atomic number
+ asym, bsym = abond.split("-")
+ ZZ_to_index[ase.data.atomic_numbers[asym]-self._min_Z, ase.data.atomic_numbers[bsym]-self._min_Z] = aidx
+
+ for abond, aidx in self.reduced_bond_to_type.items(): # type_names has a ascending order according to atomic number
+ asym, bsym = abond.split("-")
+ ZZ_to_reduced_index[ase.data.atomic_numbers[asym]-self._min_Z, ase.data.atomic_numbers[bsym]-self._min_Z] = aidx
+
+
+ self._ZZ_to_index = ZZ_to_index
+ self._ZZ_to_reduced_index = ZZ_to_reduced_index
+
+ self._index_to_ZZ = torch.zeros(
+ size=(len(self.bond_to_type),2), dtype=torch.long, device=device
+ )
+ self._reduced_index_to_ZZ = torch.zeros(
+ size=(len(self.reduced_bond_to_type),2), dtype=torch.long, device=device
+ )
+
+ for abond, aidx in self.bond_to_type.items():
+ asym, bsym = abond.split("-")
+ self._index_to_ZZ[aidx] = torch.tensor([ase.data.atomic_numbers[asym], ase.data.atomic_numbers[bsym]], dtype=torch.long, device=device)
+
+ for abond, aidx in self.reduced_bond_to_type.items():
+ asym, bsym = abond.split("-")
+ self._reduced_index_to_ZZ[aidx] = torch.tensor([ase.data.atomic_numbers[asym], ase.data.atomic_numbers[bsym]], dtype=torch.long, device=device)
+
+
+ def transform_atom(self, atomic_numbers):
+ return self.transform(atomic_numbers)
+
+ def transform_bond(self, iatomic_numbers, jatomic_numbers):
+
+ if iatomic_numbers.device != jatomic_numbers.device:
+ raise ValueError("iatomic_numbers and jatomic_numbers should be on the same device!")
+
+ if iatomic_numbers.min() < self._min_Z or iatomic_numbers.max() > self._max_Z:
+ bad_set = set(torch.unique(iatomic_numbers).cpu().tolist()) - self._valid_set
+ raise ValueError(
+ f"Data included atomic numbers {bad_set} that are not part of the atomic number -> type mapping!"
+ )
+
+ if jatomic_numbers.min() < self._min_Z or jatomic_numbers.max() > self._max_Z:
+ bad_set = set(torch.unique(jatomic_numbers).cpu().tolist()) - self._valid_set
+ raise ValueError(
+ f"Data included atomic numbers {bad_set} that are not part of the atomic number -> type mapping!"
+ )
+
+ return self._ZZ_to_index.to(device=iatomic_numbers.device)[
+ iatomic_numbers - self._min_Z, jatomic_numbers - self._min_Z
+ ]
+
+ def transform_reduced_bond(self, iatomic_numbers, jatomic_numbers):
+
+ if iatomic_numbers.device != jatomic_numbers.device:
+ raise ValueError("iatomic_numbers and jatomic_numbers should be on the same device!")
+
+ if iatomic_numbers.min() < self._min_Z or iatomic_numbers.max() > self._max_Z:
+ bad_set = set(torch.unique(iatomic_numbers).cpu().tolist()) - self._valid_set
+ raise ValueError(
+ f"Data included atomic numbers {bad_set} that are not part of the atomic number -> type mapping!"
+ )
+
+ if jatomic_numbers.min() < self._min_Z or jatomic_numbers.max() > self._max_Z:
+ bad_set = set(torch.unique(jatomic_numbers).cpu().tolist()) - self._valid_set
+ raise ValueError(
+ f"Data included atomic numbers {bad_set} that are not part of the atomic number -> type mapping!"
+ )
+
+ return self._ZZ_to_reduced_index.to(device=iatomic_numbers.device)[
+ iatomic_numbers - self._min_Z, jatomic_numbers - self._min_Z
+ ]
+
+ def untransform_atom(self, atom_types):
+ """Transform atom types back into atomic numbers"""
+ return self.untransform(atom_types)
+
+ def untransform_bond(self, bond_types):
+ """Transform bond types back into atomic numbers"""
+ return self._index_to_ZZ[bond_types].to(device=bond_types.device)
+
+ def untransform_reduced_bond(self, bond_types):
+ """Transform reduced bond types back into atomic numbers"""
+ return self._reduced_index_to_ZZ[bond_types].to(device=bond_types.device)
+
+ @property
+ def has_bond(self) -> bool:
+ return self.bond_to_type is not None
+
+ def __call__(
+ self, data: Union[AtomicDataDict.Type, AtomicData], types_required: bool = True
+ ) -> Union[AtomicDataDict.Type, AtomicData]:
+ if AtomicDataDict.EDGE_TYPE_KEY in data:
+ if AtomicDataDict.ATOMIC_NUMBERS_KEY in data:
+ warnings.warn(
+ "Data contained both EDGE_TYPE_KEY and ATOMIC_NUMBERS_KEY; ignoring ATOMIC_NUMBERS_KEY"
+ )
+ elif AtomicDataDict.ATOMIC_NUMBERS_KEY in data:
+ assert (
+ self.bond_to_type is not None
+ ), "Atomic numbers provided but there is no chemical_symbols/chemical_symbol_to_type mapping!"
+ atomic_numbers = data[AtomicDataDict.ATOMIC_NUMBERS_KEY]
+
+ assert (
+ AtomicDataDict.EDGE_INDEX_KEY in data
+ ), "The bond type mapper need a EDGE index as input."
+
+ data[AtomicDataDict.EDGE_TYPE_KEY] = \
+ self.transform_bond(
+ atomic_numbers[data[AtomicDataDict.EDGE_INDEX_KEY][0]],
+ atomic_numbers[data[AtomicDataDict.EDGE_INDEX_KEY][1]]
+ )
+ else:
+ if types_required:
+ raise KeyError(
+ "Data doesn't contain any atom type information (EDGE_TYPE_KEY or ATOMIC_NUMBERS_KEY)"
+ )
+ return super().__call__(data=data, types_required=types_required)
+
+
+
+
+
+class OrbitalMapper(BondMapper):
+ def __init__(
+ self,
+ basis: Dict[str, Union[List[str], str]],
+ chemical_symbol_to_type: Optional[Dict[str, int]] = None,
+ method: str ="e3tb",
+ device: Union[str, torch.device] = torch.device("cpu")
+ ):
+
+ """
+ This class is used to map the orbital pair index to the index of the reduced matrix element (or sk integrals when method is sktb). To construct a reduced matrix element features in each edge/node with equal sizes as well as their mappings, the following steps will be conducted:
+
+ 1. The basis of each atom will be sorted according to their names. For example, The basis ["2s", "1s", "s*", "2p"] of atom A will be sorted as ["s*", "1s", "2s", "2p"].
+
+ 2. The sorted basis will be transformed into a general basis, dubbed as full_basis. It is the least required set covering all the basis number and types of each atom. The basis will be renamed according to their angular momentum and the order after sorting. Take s orbital as a example, the first s* will be named as "1s", the second s* will be named as "2s", and so on. Same for p, d, f orbitals.
+
+ Then the mappings and masks used to guide the construction of hamiltonian will be constructed. The mappings includes:
+
+ Mappings:
+ fullbasis_to_basis, basis_to_fullbasis: which function as their names
+ orbpair_maps: the mapping from orbital pairs of full basis to the reduced matrix element (or sk integrals) index.
+ orbpairtype_maps: the mapping from the types of orbital pair (e.g. "s-s", "s-p", "p-p") to the reduced matrix element (or sk integrals) index.
+ skonsite_maps: the mapping from the orbital to the sk onsite energies index.
+ skonsitetype_maps: the mapping from the orbital type (e.g. "s", "p", "d", "f") to the sk onsite energies index.
+ orbital_maps: the mapping from the orbital to the index of the corresponding lines/column in hamiltonian blocks.
+ orbpair_irreps: the e3nn irreducible representations of the full reduced matrix element edge/node features.
+
+ Masks:
+ mask_to_basis: the mask used to map the (line/column of) hamiltonian of full basis to the (line/column of) block of original basis of each atom.
+ mask_to_erme: the mask used to map the hopping block's flattened reduced matrix element (up tri-diagonal block of hamiltonian) of full basis to it of the original basis.
+ mask_to_nrme: the mask used to map the onsite block's flattened reduced matrix element (diagonal block of hamiltonian) of full basis to it of the original basis.
+
+ Parameters
+ ----------
+ basis : dict
+ the definition of the basis set, should be like:
+ {"A":"2s2p3d1f", "B":"1s2f3d1f"} or
+ {"A":["2s", "2p"], "B":["2s", "2p"]}
+ when list, "2s" indicate a "s" orbital in the second shell.
+ when str, "2s" indicates two s orbitals,
+ "2s2p3d4f" is equivilent to ["1s","2s", "1p", "2p", "1d", "2d", "3d", "1f"]
+ """
+
+ #TODO: use OrderedDict to fix the order of the dict used as index map
+ if chemical_symbol_to_type is not None:
+ assert set(basis.keys()) == set(chemical_symbol_to_type.keys())
+ super(OrbitalMapper, self).__init__(chemical_symbol_to_type=chemical_symbol_to_type, device=device)
+ else:
+ super(OrbitalMapper, self).__init__(chemical_symbols=list(basis.keys()), device=device)
+
+ self.basis = basis
+ self.method = method
+ self.device = device
+
+ if self.method not in ["e3tb", "sktb"]:
+ raise ValueError
+
+ if isinstance(self.basis[self.type_names[0]], str):
+ orbtype_count = {"s":0, "p":0, "d":0, "f":0}
+ orbs = map(lambda bs: re.findall(r'[1-9]+[A-Za-z]', bs), self.basis.values())
+ for ib in orbs:
+ for io in ib:
+ if int(io[0]) > orbtype_count[io[1]]:
+ orbtype_count[io[1]] = int(io[0])
+ # split into list basis
+ basis = {k:[] for k in self.type_names}
+ for ib in self.basis.keys():
+ for io in ["s", "p", "d", "f"]:
+ if io in self.basis[ib]:
+ basis[ib].extend([str(i)+io for i in range(1, int(re.findall(r'[1-9]+'+io, self.basis[ib])[0][0])+1)])
+ self.basis = basis
+
+ elif isinstance(self.basis[self.type_names[0]], list):
+ nb = len(self.type_names)
+ orbtype_count = {"s":[0]*nb, "p":[0]*nb, "d":[0]*nb, "f":[0]*nb}
+ for ib, bt in enumerate(self.type_names):
+ for io in self.basis[bt]:
+ orb = re.findall(r'[A-Za-z]', io)[0]
+ orbtype_count[orb][ib] += 1
+
+ for ko in orbtype_count.keys():
+ orbtype_count[ko] = max(orbtype_count[ko])
+
+ self.orbtype_count = orbtype_count
+ self.full_basis_norb = 1 * orbtype_count["s"] + 3 * orbtype_count["p"] + 5 * orbtype_count["d"] + 7 * orbtype_count["f"]
+
+
+ if self.method == "e3tb":
+ self.reduced_matrix_element = int(((orbtype_count["s"] + 9 * orbtype_count["p"] + 25 * orbtype_count["d"] + 49 * orbtype_count["f"]) + \
+ self.full_basis_norb ** 2)/2) # reduce onsite elements by blocks. we cannot reduce it by element since the rme will pass into CG basis to form the whole block
+ else:
+ # two factor: this outside one is the number of min(l,l')+1, ie. the number of sk integrals for each orbital pair.
+ # the inside one the type of bond considering the interaction between different orbitals. s-p -> p-s. there are 2 types of bond. and 1 type of s-s.
+ self.reduced_matrix_element = (
+ 1 * orbtype_count["s"] * orbtype_count["s"] + \
+ 2 * orbtype_count["s"] * orbtype_count["p"] + \
+ 2 * orbtype_count["s"] * orbtype_count["d"] + \
+ 2 * orbtype_count["s"] * orbtype_count["f"]
+ ) + \
+ 2 * (
+ 1 * orbtype_count["p"] * orbtype_count["p"] + \
+ 2 * orbtype_count["p"] * orbtype_count["d"] + \
+ 2 * orbtype_count["p"] * orbtype_count["f"]
+ ) + \
+ 3 * (
+ 1 * orbtype_count["d"] * orbtype_count["d"] + \
+ 2 * orbtype_count["d"] * orbtype_count["f"]
+ ) + \
+ 4 * (orbtype_count["f"] * orbtype_count["f"])
+
+ self.reduced_matrix_element = self.reduced_matrix_element + orbtype_count["s"] + 2*orbtype_count["p"] + 3*orbtype_count["d"] + 4*orbtype_count["f"]
+ self.reduced_matrix_element = int(self.reduced_matrix_element / 2)
+ self.n_onsite_Es = orbtype_count["s"] + orbtype_count["p"] + orbtype_count["d"] + orbtype_count["f"]
+
+ # sort the basis
+ for ib in self.basis.keys():
+ self.basis[ib] = sorted(
+ self.basis[ib],
+ key=lambda s: (anglrMId[re.findall(r"[a-z]",s)[0]], re.findall(r"[1-9*]",s)[0])
+ )
+
+ # TODO: get full basis set
+ full_basis = []
+ for io in ["s", "p", "d", "f"]:
+ full_basis = full_basis + [str(i)+io for i in range(1, orbtype_count[io]+1)]
+ self.full_basis = full_basis
+
+ # TODO: get the mapping from list basis to full basis
+ self.basis_to_full_basis = {}
+ self.atom_norb = torch.zeros(len(self.type_names), dtype=torch.long, device=self.device)
+ for ib in self.basis.keys():
+ count_dict = {"s":0, "p":0, "d":0, "f":0}
+ self.basis_to_full_basis.setdefault(ib, {})
+ for o in self.basis[ib]:
+ io = re.findall(r"[a-z]", o)[0]
+ l = anglrMId[io]
+ count_dict[io] += 1
+ self.atom_norb[self.chemical_symbol_to_type[ib]] += 2*l+1
+
+ self.basis_to_full_basis[ib][o] = str(count_dict[io])+io
+
+ # get the mapping from full basis to list basis
+ self.full_basis_to_basis = {}
+ for at, maps in self.basis_to_full_basis.items():
+ self.full_basis_to_basis[at] = {}
+ for k,v in maps.items():
+ self.full_basis_to_basis[at].update({v:k})
+
+ # Get the mask for mapping from full basis to atom specific basis
+ self.mask_to_basis = torch.zeros(len(self.type_names), self.full_basis_norb, device=self.device, dtype=torch.bool)
+
+ for ib in self.basis.keys():
+ ibasis = list(self.basis_to_full_basis[ib].values())
+ ist = 0
+ for io in self.full_basis:
+ l = anglrMId[io[1]]
+ if io in ibasis:
+ self.mask_to_basis[self.chemical_symbol_to_type[ib]][ist:ist+2*l+1] = True
+
+ ist += 2*l+1
+
+ assert (self.mask_to_basis.sum(dim=1).int()-self.atom_norb).abs().sum() <= 1e-6
+
+ self.get_orbpair_maps()
+ # the mask to map the full basis reduced matrix element to the original basis reduced matrix element
+ self.mask_to_erme = torch.zeros(len(self.bond_types), self.reduced_matrix_element, dtype=torch.bool, device=self.device)
+ self.mask_to_nrme = torch.zeros(len(self.type_names), self.reduced_matrix_element, dtype=torch.bool, device=self.device)
+ for ib, bb in self.basis.items():
+ for io in bb:
+ iof = self.basis_to_full_basis[ib][io]
+ for jo in bb:
+ jof = self.basis_to_full_basis[ib][jo]
+ if self.orbpair_maps.get(iof+"-"+jof) is not None:
+ self.mask_to_nrme[self.chemical_symbol_to_type[ib]][self.orbpair_maps[iof+"-"+jof]] = True
+
+ for ib in self.bond_to_type.keys():
+ a,b = ib.split("-")
+ for io in self.basis[a]:
+ iof = self.basis_to_full_basis[a][io]
+ for jo in self.basis[b]:
+ jof = self.basis_to_full_basis[b][jo]
+ if self.orbpair_maps.get(iof+"-"+jof) is not None:
+ self.mask_to_erme[self.bond_to_type[ib]][self.orbpair_maps[iof+"-"+jof]] = True
+ elif self.orbpair_maps.get(jof+"-"+iof) is not None:
+ self.mask_to_erme[self.bond_to_type[ib]][self.orbpair_maps[jof+"-"+iof]] = True
+
+ def get_orbpairtype_maps(self):
+ """
+ The function `get_orbpairtype_maps` creates a mapping of orbital pair types, such as s-s, "s-p",
+ to slices based on the number of hops between them.
+ :return: a dictionary called `pairtype_map`.
+ """
+
+ self.orbpairtype_maps = {}
+ ist = 0
+ for i, io in enumerate(["s", "p", "d", "f"]):
+ if self.orbtype_count[io] != 0:
+ for jo in ["s", "p", "d", "f"][i:]:
+ if self.orbtype_count[jo] != 0:
+ orb_pair = io+"-"+jo
+ il, jl = anglrMId[io], anglrMId[jo]
+ if self.method == "e3tb":
+ n_rme = (2*il+1) * (2*jl+1)
+ else:
+ n_rme = min(il, jl)+1
+ numhops = self.orbtype_count[io] * self.orbtype_count[jo] * n_rme
+ if io == jo:
+ numhops += self.orbtype_count[jo] * n_rme
+ numhops = int(numhops / 2)
+ self.orbpairtype_maps[orb_pair] = slice(ist, ist+numhops)
+
+ ist += numhops
+
+ return self.orbpairtype_maps
+
+ def get_orbpair_maps(self):
+
+ if hasattr(self, "orbpair_maps"):
+ return self.orbpair_maps
+
+ if not hasattr(self, "orbpairtype_maps"):
+ self.get_orbpairtype_maps()
+
+ self.orbpair_maps = {}
+ for i, io in enumerate(self.full_basis):
+ for jo in self.full_basis[i:]:
+ full_basis_pair = io+"-"+jo
+ ir, jr = int(full_basis_pair[0]), int(full_basis_pair[3])
+ iio, jjo = full_basis_pair[1], full_basis_pair[4]
+ il, jl = anglrMId[iio], anglrMId[jjo]
+
+ if self.method == "e3tb":
+ n_feature = (2*il+1) * (2*jl+1)
+ else:
+ n_feature = min(il, jl)+1
+ if iio == jjo:
+ start = self.orbpairtype_maps[iio+"-"+jjo].start + \
+ n_feature * ((2*self.orbtype_count[jjo]+2-ir) * (ir-1) / 2 + (jr - ir))
+ else:
+ start = self.orbpairtype_maps[iio+"-"+jjo].start + \
+ n_feature * ((ir-1)*self.orbtype_count[jjo]+(jr-1))
+ start = int(start)
+ self.orbpair_maps[io+"-"+jo] = slice(start, start+n_feature)
+
+ return self.orbpair_maps
+
+ def get_skonsite_maps(self):
+
+ assert self.method == "sktb", "Only sktb orbitalmapper have skonsite maps."
+
+ if hasattr(self, "skonsite_maps"):
+ return self.skonsite_maps
+
+ if not hasattr(self, "skonsitetype_maps"):
+ self.get_skonsitetype_maps()
+
+ self.skonsite_maps = {}
+ for i, io in enumerate(self.full_basis):
+ ir= int(io[0])
+ iio = io[1]
+
+ start = int(self.skonsitetype_maps[iio].start + (ir-1))
+ self.skonsite_maps[io] = slice(start, start+1)
+
+ return self.skonsite_maps
+
+ def get_skonsitetype_maps(self):
+ self.skonsitetype_maps = {}
+ ist = 0
+
+ assert self.method == "sktb", "Only sktb orbitalmapper have skonsite maps."
+ for i, io in enumerate(["s", "p", "d", "f"]):
+ if self.orbtype_count[io] != 0:
+ il = anglrMId[io]
+ numonsites = self.orbtype_count[io]
+
+ self.skonsitetype_maps[io] = slice(ist, ist+numonsites)
+
+ ist += numonsites
+
+ return self.skonsitetype_maps
+
+ # also need to think if we modify as this, how can we add extra basis when fitting.
+
+ def get_orbital_maps(self):
+ # simply get a 1-d slice for each atom species.
+
+ self.orbital_maps = {}
+ self.norbs = {}
+
+ for ib in self.basis.keys():
+ orbital_list = self.basis[ib]
+ slices = {}
+ start_index = 0
+
+ self.norbs.setdefault(ib, 0)
+ for orb in orbital_list:
+ orb_l = re.findall(r'[A-Za-z]', orb)[0]
+ increment = (2*anglrMId[orb_l]+1)
+ self.norbs[ib] += increment
+ end_index = start_index + increment
+
+ slices[orb] = slice(start_index, end_index)
+ start_index = end_index
+
+ self.orbital_maps[ib] = slices
+
+ return self.orbital_maps
+
+ def get_irreps(self, no_parity=False):
+ assert self.method == "e3tb", "Only support e3tb method for now."
+
+ if hasattr(self, "orbpair_irreps"):
+ if self.no_parity == no_parity:
+ return self.orbpair_irreps
+
+ self.no_parity = no_parity
+
+ if not hasattr(self, "orbpairtype_maps"):
+ self.get_orbpairtype_maps()
+
+ irs = []
+ if no_parity:
+ factor = 1
+ else:
+ factor = -1
+
+ irs = []
+ for pair, sli in self.orbpairtype_maps.items():
+ l1, l2 = anglrMId[pair[0]], anglrMId[pair[2]]
+ p = factor**(l1+l2)
+ required_ls = range(abs(l1 - l2), l1 + l2 + 1)
+ required_irreps = [(1,(l, p)) for l in required_ls]
+ irs += required_irreps*int((sli.stop-sli.start)/(2*l1+1)/(2*l2+1))
+
+ self.orbpair_irreps = o3.Irreps(irs)
+ return self.orbpair_irreps
+
+ def __eq__(self, other):
+ return self.basis == other.basis and self.method == other.method
\ No newline at end of file
diff --git a/dptb/data/use_data.ipynb b/dptb/data/use_data.ipynb
new file mode 100644
index 00000000..1d9c6584
--- /dev/null
+++ b/dptb/data/use_data.ipynb
@@ -0,0 +1,499 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from build import dataset_from_config\n",
+ "from dptb.utils.config import Config"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "config = {\n",
+ " \"root\": \"/root/nequip_data/\",\n",
+ " \"dataset\": \"npz\",\n",
+ " \"dataset_file_name\": \"/root/nequip_data/Si8-100K.npz\",\n",
+ " \"key_mapping\":{\n",
+ " \"pos\":\"pos\",\n",
+ " \"atomic_numbers\":\"atomic_numbers\",\n",
+ " \"kpoints\": \"kpoint\",\n",
+ " \"pbc\": \"pbc\",\n",
+ " \"cell\": \"cell\",\n",
+ " \"eigenvalues\": \"eigenvalue\"\n",
+ " },\n",
+ " \"npz_fixed_field_keys\": [\"kpoint\", \"pbc\"],\n",
+ " \"graph_field\":[\"eigenvalues\"],\n",
+ " \"chemical_symbols\": [\"Si\", \"C\"],\n",
+ " \"r_max\": 6.0\n",
+ "}\n",
+ "\n",
+ "config = Config(config=config)\n",
+ "# dataset: npz # type of data set, can be npz or ase\n",
+ "# dataset_url: http://quantum-machine.org/gdml/data/npz/toluene_ccsd_t.zip # url to download the npz. optional\n",
+ "# dataset_file_name: ./benchmark_data/toluene_ccsd_t-train.npz # path to data set file\n",
+ "# key_mapping:\n",
+ "# z: atomic_numbers # atomic species, integers\n",
+ "# E: total_energy # total potential eneriges to train to\n",
+ "# F: forces # atomic forces to train to\n",
+ "# R: pos # raw atomic positions\n",
+ "# npz_fixed_field_keys: # fields that are repeated across different examples\n",
+ "# - atomic_numbers\n",
+ "\n",
+ "# chemical_symbols:\n",
+ "# - H\n",
+ "# - C"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Processing dataset...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "dataset = dataset_from_config(config=config, prefix=\"dataset\")\n",
+ "\n",
+ "from dptb.data.dataloader import DataLoader\n",
+ "\n",
+ "dl = DataLoader(dataset, 3)\n",
+ "\n",
+ "data = next(iter(dl))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 1., 1., -1.],\n",
+ " [ 1., 1., 1.],\n",
+ " [ 0., 1., -1.],\n",
+ " [ 0., 1., 1.],\n",
+ " [ 1., 0., -1.],\n",
+ " [ 0., 0., -1.],\n",
+ " [ 1., 0., 1.],\n",
+ " [ 0., 0., 1.],\n",
+ " [ 0., 1., 0.],\n",
+ " [ 1., 0., 0.],\n",
+ " [ 0., 0., 0.],\n",
+ " [ 1., 1., 0.]])"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "\n",
+ "dataset[0].edge_cell_shift[dataset[0].edge_index[0].eq(1)&dataset[0].edge_index[1].eq(2)], dataset[0].edge_cell_shift[dataset[0].edge_index[0].eq(1)&dataset[0].edge_index[1].eq(2)]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([False, False, False, False, False, False, False, False, False, False,\n",
+ " True, False, False, False, False, False, False, True, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, True, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, True, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, True,\n",
+ " False, False, False, False, False, False, False, True, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, True, False, True,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " True, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, True, False, False,\n",
+ " False, True, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, True, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, True, False, False, False, True, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, False, False, True,\n",
+ " False, False, False, False, False, False, False, False, False, True,\n",
+ " False, False, False, False, False, False, False, False, False, False,\n",
+ " True, False, False, True, False, False, False, False, False, False,\n",
+ " False, False, False, False, False, False, False, True, False, False,\n",
+ " False, False, False, True, False, False, False, False, False, True,\n",
+ " False, True, True, True])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dataset[0].edge_index[0].eq(dataset[0].edge_index[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'C-C': 0, 'C-Si': 1, 'Si-C': 2, 'Si-Si': 3}"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "dataset.type_mapper.bond_to_type"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.nn._sktb import SKTB\n",
+ "sktb = SKTB(\n",
+ " basis={\"Si\":[\"3s\", \"3p\", \"p*\", \"s*\"], \"C\":[\"2s\",\"2p\"]},\n",
+ " onsite=\"uniform\",\n",
+ " hopping=\"powerlaw\",\n",
+ " overlap=True\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.data.AtomicDataDict import with_edge_vectors, with_onsitenv_vectors\n",
+ "\n",
+ "data = with_edge_vectors(data.to_dict())\n",
+ "data = with_onsitenv_vectors(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "data[\"atomic_numbers\"] = dataset.type_mapper.untransform(data[\"atom_types\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = sktb(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "20"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sktb.idp.edge_reduced_matrix_element"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "torch.Size([24, 4])"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[\"node_features\"].shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.nn._hamiltonian import SKHamiltonian\n",
+ "\n",
+ "skh = SKHamiltonian(basis={\"Si\":[\"3s\", \"3p\", \"p*\", \"s*\"], \"C\":[\"2s\",\"2p\"]})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = skh(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "torch.Size([24, 42])"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[\"node_features\"].shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.nn._hamiltonian import E3Hamiltonian\n",
+ "e3h = E3Hamiltonian(basis={\"Si\":[\"3s\", \"3p\", \"p*\", \"s*\"], \"C\":[\"2s\",\"2p\"]}, decompose=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = e3h(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([ True, True, True, True, False, True, False, False, True, False,\n",
+ " False, True, False, False, True, False, False, True, False, False,\n",
+ " True, False, False, True, False, False, True, False, True, False,\n",
+ " False, False, False, False, True, False, False, True, False, False,\n",
+ " False, False, False, True, False, False, True, False, False, False,\n",
+ " False, False, True, False, False, True, False, False, False, False,\n",
+ " False, True, False, False])"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[\"edge_features\"][0].abs().gt(1e-5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.data.AtomicData import AtomicData\n",
+ "from dptb.utils.torch_geometric import Batch\n",
+ "\n",
+ "bdata = Batch.from_dict(data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "RuntimeError",
+ "evalue": "Cannot reconstruct data list from batch because the batch object was not created using `Batch.from_data_list()`.",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32m/root/deeptb/dptb/data/use_data.ipynb Cell 13\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> 1\u001b[0m bdata\u001b[39m.\u001b[39;49mget_example(\u001b[39m0\u001b[39;49m)\n",
+ "File \u001b[0;32m/opt/miniconda/envs/deeptb/lib/python3.8/site-packages/dptb/utils/torch_geometric/batch.py:176\u001b[0m, in \u001b[0;36mBatch.get_example\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[39mr\u001b[39m\u001b[39m\"\"\"Reconstructs the :class:`torch_geometric.data.Data` object at index\u001b[39;00m\n\u001b[1;32m 171\u001b[0m \u001b[39m:obj:`idx` from the batch object.\u001b[39;00m\n\u001b[1;32m 172\u001b[0m \u001b[39mThe batch object must have been created via :meth:`from_data_list` in\u001b[39;00m\n\u001b[1;32m 173\u001b[0m \u001b[39morder to be able to reconstruct the initial objects.\"\"\"\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m__slices__ \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 176\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 177\u001b[0m (\n\u001b[1;32m 178\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot reconstruct data list from batch because the batch \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 179\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mobject was not created using `Batch.from_data_list()`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 180\u001b[0m )\n\u001b[1;32m 181\u001b[0m )\n\u001b[1;32m 183\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m__data_class__()\n\u001b[1;32m 184\u001b[0m idx \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_graphs \u001b[39m+\u001b[39m idx \u001b[39mif\u001b[39;00m idx \u001b[39m<\u001b[39m \u001b[39m0\u001b[39m \u001b[39melse\u001b[39;00m idx\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: Cannot reconstruct data list from batch because the batch object was not created using `Batch.from_data_list()`."
+ ]
+ }
+ ],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.data.transforms import OrbitalMapper\n",
+ "\n",
+ "idp = OrbitalMapper(basis={\"Si\": \"2s2p1d\", \"C\":\"1s1p1d\"})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'1s-1s': slice(0, 1, None),\n",
+ " '1s-2s': slice(1, 2, None),\n",
+ " '1s-1p': slice(3, 6, None),\n",
+ " '1s-2p': slice(6, 9, None),\n",
+ " '1s-1d': slice(15, 20, None),\n",
+ " '2s-2s': slice(2, 3, None),\n",
+ " '2s-1p': slice(9, 12, None),\n",
+ " '2s-2p': slice(12, 15, None),\n",
+ " '2s-1d': slice(20, 25, None),\n",
+ " '1p-1p': slice(25, 34, None),\n",
+ " '1p-2p': slice(34, 43, None),\n",
+ " '1p-1d': slice(52, 67, None),\n",
+ " '2p-2p': slice(43, 52, None),\n",
+ " '2p-1d': slice(67, 82, None),\n",
+ " '1d-1d': slice(82, 107, None)}"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "idp.get_node_maps()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'1s-1s': slice(0, 1, None),\n",
+ " '1s-2s': slice(1, 2, None),\n",
+ " '1s-1p': slice(3, 6, None),\n",
+ " '1s-2p': slice(6, 9, None),\n",
+ " '1s-1d': slice(15, 20, None),\n",
+ " '2s-2s': slice(2, 3, None),\n",
+ " '2s-1p': slice(9, 12, None),\n",
+ " '2s-2p': slice(12, 15, None),\n",
+ " '2s-1d': slice(20, 25, None),\n",
+ " '1p-1p': slice(25, 34, None),\n",
+ " '1p-2p': slice(34, 43, None),\n",
+ " '1p-1d': slice(52, 67, None),\n",
+ " '2p-2p': slice(43, 52, None),\n",
+ " '2p-1d': slice(67, 82, None),\n",
+ " '1d-1d': slice(82, 107, None)}"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "idp.node_maps"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "deeptb",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.13"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/dptb/data/util.py b/dptb/data/util.py
new file mode 100644
index 00000000..494c2f8f
--- /dev/null
+++ b/dptb/data/util.py
@@ -0,0 +1,4 @@
+import torch
+
+# There is no built-in way to check if a Tensor is of an integer type
+_TORCH_INTEGER_DTYPES = (torch.int, torch.long)
diff --git a/dptb/entrypoints/__init__.py b/dptb/entrypoints/__init__.py
index 4e3c5d99..b921c542 100644
--- a/dptb/entrypoints/__init__.py
+++ b/dptb/entrypoints/__init__.py
@@ -1,5 +1,5 @@
from dptb.entrypoints.train import train
from dptb.entrypoints.config import config
-from dptb.entrypoints.run import run
+# from dptb.entrypoints.run import run
from dptb.entrypoints.test import _test as test
from dptb.entrypoints.bond import bond
\ No newline at end of file
diff --git a/dptb/entrypoints/data.py b/dptb/entrypoints/data.py
new file mode 100644
index 00000000..d19f25fb
--- /dev/null
+++ b/dptb/entrypoints/data.py
@@ -0,0 +1,39 @@
+import os
+from typing import Dict, List, Optional, Any
+from dptb.utils.tools import j_loader
+from dptb.utils.argcheck import normalize
+from dptb.data.interfaces.abacus import recursive_parse
+
+def data(
+ INPUT: str,
+ log_level: int,
+ log_path: Optional[str],
+ **kwargs
+):
+ jdata = j_loader(INPUT)
+
+ # ABACUS parsing input like:
+ # { "type": "ABACUS",
+ # "parse_arguments": {
+ # "input_path": "alice_*/*_bob/system_No_*",
+ # "preprocess_dir": "charlie/david",
+ # "only_overlap": false,
+ # "get_Hamiltonian": true,
+ # "add_overlap": true,
+ # "get_eigenvalues": true } }
+ if jdata["type"] == "ABACUS":
+ abacus_args = jdata["parse_arguments"]
+ assert abacus_args.get("input_path") is not None, "ABACUS calculation results MUST be provided."
+ assert abacus_args.get("preprocess_dir") is not None, "Please assign a dictionary to store preprocess files."
+
+ print("Begin parsing ABACUS output...")
+ recursive_parse(**abacus_args)
+ print("Finished parsing ABACUS output.")
+
+ ## write all h5 files to be used in building AtomicData
+ #with open(os.path.join(abacus_args["preprocess_dir"], "AtomicData_file.txt"), "w") as f:
+ # for filename in h5_filenames:
+ # f.write(filename + "\n")
+
+ else:
+ raise Exception("Not supported software output.")
\ No newline at end of file
diff --git a/dptb/entrypoints/main.py b/dptb/entrypoints/main.py
index 226bf685..20def5a4 100644
--- a/dptb/entrypoints/main.py
+++ b/dptb/entrypoints/main.py
@@ -8,6 +8,7 @@
from dptb.entrypoints.run import run
from dptb.entrypoints.bond import bond
from dptb.entrypoints.nrl2json import nrl2json
+from dptb.entrypoints.data import data
from dptb.utils.loggers import set_log_handles
def get_ll(log_level: str) -> int:
@@ -168,13 +169,6 @@ def main_parser() -> argparse.ArgumentParser:
help="Restart the training from the provided checkpoint.",
)
- parser_train.add_argument(
- "-sk",
- "--train-sk",
- action="store_true",
- help="Trainging NNSKTB parameters.",
- )
-
parser_train.add_argument(
"-crt",
"--use-correction",
@@ -190,13 +184,6 @@ def main_parser() -> argparse.ArgumentParser:
help="Initialize the training from the frozen model.",
)
- parser_train.add_argument(
- "-f",
- "--freeze",
- action="store_true",
- help="Initialize the training from the frozen model.",
- )
-
parser_train.add_argument(
"-o",
"--output",
@@ -226,13 +213,6 @@ def main_parser() -> argparse.ArgumentParser:
help="Initialize the model by the provided checkpoint.",
)
- parser_test.add_argument(
- "-sk",
- "--test-sk",
- action="store_true",
- help="Test NNSKTB parameters.",
- )
-
parser_test.add_argument(
"-crt",
"--use-correction",
@@ -287,13 +267,6 @@ def main_parser() -> argparse.ArgumentParser:
help="The output files in postprocess run."
)
- parser_run.add_argument(
- "-sk",
- "--run_sk",
- action="store_true",
- help="using NNSKTB parameters TB models for post-run."
- )
-
parser_run.add_argument(
"-crt",
"--use-correction",
@@ -302,6 +275,20 @@ def main_parser() -> argparse.ArgumentParser:
help="Use nnsktb correction when training dptb",
)
+ # preprocess data
+ parser_data = subparsers.add_parser(
+ "data",
+ parents=[parser_log],
+ help="preprocess software output",
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+ )
+
+ parser_data.add_argument(
+ "INPUT", help="the input parameter file in json or yaml format",
+ type=str,
+ default=None
+ )
+
return parser
def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
@@ -352,3 +339,5 @@ def main():
elif args.command == 'n2j':
nrl2json(**dict_args)
+ elif args.command == 'data':
+ data(**dict_args)
diff --git a/dptb/entrypoints/run.py b/dptb/entrypoints/run.py
index afc7ccf5..f09d3ee2 100644
--- a/dptb/entrypoints/run.py
+++ b/dptb/entrypoints/run.py
@@ -1,232 +1,156 @@
-import logging
-import json
-import os
-import struct
-import time
-import torch
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-from dptb.plugins.train_logger import Logger
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.plugins.init_dptb import InitDPTBModel
-from dptb.utils.argcheck import normalize, normalize_run
-from dptb.utils.tools import j_loader
-from dptb.utils.loggers import set_log_handles
-from dptb.utils.tools import j_must_have
-from dptb.utils.constants import dtype_dict
-from dptb.nnops.apihost import NNSKHost, DPTBHost
-from dptb.nnops.NN2HRK import NN2HRK
-from ase.io import read,write
-from dptb.postprocess.bandstructure.band import bandcalc
-from dptb.postprocess.bandstructure.dos import doscalc, pdoscalc
-from dptb.postprocess.bandstructure.fermisurface import fs2dcalc, fs3dcalc
-from dptb.postprocess.bandstructure.ifermi_api import ifermiapi, ifermi_installed, pymatgen_installed
-from dptb.postprocess.write_skparam import WriteNNSKParam
-from dptb.postprocess.NEGF import NEGF
-from dptb.postprocess.tbtrans_init import TBTransInputSet,sisl_installed
-
-__all__ = ["run"]
-
-log = logging.getLogger(__name__)
-
-def run(
- INPUT: str,
- init_model: str,
- output: str,
- run_sk: bool,
- structure: str,
- log_level: int,
- log_path: Optional[str],
- use_correction: Optional[str],
- **kwargs
- ):
+# import logging
+# import json
+# import os
+# import time
+# import torch
+# from pathlib import Path
+# from typing import Optional
+# from dptb.plugins.train_logger import Logger
+# from dptb.utils.argcheck import normalize_run
+# from dptb.utils.tools import j_loader
+# from dptb.utils.loggers import set_log_handles
+# from dptb.utils.tools import j_must_have
+# from dptb.nn.build import build_model
+# from dptb.postprocess.bandstructure.band import bandcalc
+# from dptb.postprocess.bandstructure.dos import doscalc, pdoscalc
+# from dptb.postprocess.bandstructure.fermisurface import fs2dcalc, fs3dcalc
+# from dptb.postprocess.bandstructure.ifermi_api import ifermiapi, ifermi_installed, pymatgen_installed
+# from dptb.postprocess.write_skparam import WriteNNSKParam
+# from dptb.postprocess.NEGF import NEGF
+# from dptb.postprocess.tbtrans_init import TBTransInputSet,sisl_installed
+
+# __all__ = ["run"]
+
+# log = logging.getLogger(__name__)
+
+# def run(
+# INPUT: str,
+# init_model: str,
+# output: str,
+# structure: str,
+# log_level: int,
+# log_path: Optional[str],
+# **kwargs
+# ):
- run_opt = {
- "run_sk": run_sk,
- "init_model":init_model,
- "structure":structure,
- "log_path": log_path,
- "log_level": log_level,
- "use_correction":use_correction
- }
-
- if all((use_correction, run_sk)):
- log.error(msg="--use-correction and --train_sk should not be set at the same time")
- raise RuntimeError
+# run_opt = {
+# "init_model":init_model,
+# "structure":structure,
+# "log_path": log_path,
+# "log_level": log_level,
+# }
+
+# # output folder.
+# if output:
+
+# Path(output).parent.mkdir(exist_ok=True, parents=True)
+# Path(output).mkdir(exist_ok=True, parents=True)
+# results_path = os.path.join(str(output), "results")
+# Path(results_path).mkdir(exist_ok=True, parents=True)
+# if not log_path:
+# log_path = os.path.join(str(output), "log/log.txt")
+# Path(log_path).parent.mkdir(exist_ok=True, parents=True)
+
+# run_opt.update({
+# "output": str(Path(output).absolute()),
+# "results_path": str(Path(results_path).absolute()),
+# "log_path": str(Path(log_path).absolute())
+# })
- jdata = j_loader(INPUT)
- jdata = normalize_run(jdata)
+# jdata = j_loader(INPUT)
+# jdata = normalize_run(jdata)
- if all((jdata["init_model"]["path"], run_opt["init_model"])):
- raise RuntimeError(
- "init-model in config and command line is in conflict, turn off one of then to avoid this error !"
- )
-
- if run_opt["init_model"] is None:
- log.info(msg="model_ckpt is not set in command line, read from input config file.")
-
- if run_sk:
- if jdata["init_model"]["path"] is not None:
- run_opt["init_model"] = jdata["init_model"]
- else:
- log.error(msg="Error! init_model is not set in config file and command line.")
- raise RuntimeError
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"])==0:
- log.error("Error! list mode init_model in config file cannot be empty!")
- raise RuntimeError
- else:
- if jdata["init_model"]["path"] is not None:
- run_opt["init_model"] = jdata["init_model"]
- else:
- log.error(msg="Error! init_model is not set in config file and command line.")
- raise RuntimeError
- if isinstance(run_opt["init_model"]["path"], list):
- raise RuntimeError(
- "loading lists of checkpoints is only supported in init_nnsk!"
- )
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"]) == 1:
- run_opt["init_model"]["path"] = run_opt["init_model"]["path"][0]
- else:
- path = run_opt["init_model"]
- run_opt["init_model"] = jdata["init_model"]
- run_opt["init_model"]["path"] = path
+# set_log_handles(log_level, Path(log_path) if log_path else None)
+
+# f = torch.load(run_opt["init_model"])
+# jdata["model_options"] = f["config"]["model_options"]
+# del f
- task_options = j_must_have(jdata, "task_options")
- task = task_options["task"]
- use_gui = jdata.get("use_gui", False)
- task_options.update({"use_gui": use_gui})
-
- model_ckpt = run_opt["init_model"]["path"]
- # init_type = model_ckpt.split(".")[-1]
- # if init_type not in ["json", "pth"]:
- # log.error(msg="Error! the model file should be a json or pth file.")
- # raise RuntimeError
-
- # if init_type == "json":
- # jdata = host_normalize(jdata)
- # if run_sk:
- # jdata.update({"init_model": {"path": model_ckpt,"interpolate": False}})
- # else:
- # jdata.update({"init_model": model_ckpt})
-
- if run_opt['structure'] is None:
- log.warning(msg="Warning! structure is not set in run option, read from input config file.")
- structure = j_must_have(jdata, "structure")
- run_opt.update({"structure":structure})
-
- print(run_opt["structure"])
-
- if not run_sk:
- if run_opt['use_correction'] is None and jdata.get('use_correction',None) != None:
- use_correction = jdata['use_correction']
- run_opt.update({"use_correction":use_correction})
- log.info(msg="use_correction is not set in run option, read from input config file.")
-
- # output folder.
- if output:
-
- Path(output).parent.mkdir(exist_ok=True, parents=True)
- Path(output).mkdir(exist_ok=True, parents=True)
- results_path = os.path.join(str(output), "results")
- Path(results_path).mkdir(exist_ok=True, parents=True)
- if not log_path:
- log_path = os.path.join(str(output), "log/log.txt")
- Path(log_path).parent.mkdir(exist_ok=True, parents=True)
-
- run_opt.update({
- "output": str(Path(output).absolute()),
- "results_path": str(Path(results_path).absolute()),
- "log_path": str(Path(log_path).absolute())
- })
-
- set_log_handles(log_level, Path(log_path) if log_path else None)
-
- if jdata.get("common_options", None):
- # in this case jdata must have common options
- str_dtype = jdata["common_options"]["dtype"]
- # jdata["common_options"]["dtype"] = dtype_dict[jdata["common_options"]["dtype"]]
-
- if run_sk:
- apihost = NNSKHost(checkpoint=model_ckpt, config=jdata)
- apihost.register_plugin(InitSKModel())
- apihost.build()
- apiHrk = NN2HRK(apihost=apihost, mode='nnsk')
- else:
- apihost = DPTBHost(dptbmodel=model_ckpt,use_correction=use_correction)
- apihost.register_plugin(InitDPTBModel())
- apihost.build()
- apiHrk = NN2HRK(apihost=apihost, mode='dptb')
+# task_options = j_must_have(jdata, "task_options")
+# task = task_options["task"]
+# use_gui = jdata.get("use_gui", False)
+# task_options.update({"use_gui": use_gui})
+
+# if run_opt['structure'] is None:
+# log.warning(msg="Warning! structure is not set in run option, read from input config file.")
+# structure = j_must_have(jdata, "structure")
+# run_opt.update({"structure":structure})
+# else:
+# structure = run_opt["structure"]
+
+# print(run_opt["structure"])
+
+# if jdata.get("common_options", None):
+# # in this case jdata must have common options
+# str_dtype = jdata["common_options"]["dtype"]
+# # jdata["common_options"]["dtype"] = dtype_dict[jdata["common_options"]["dtype"]]
+
+# model = build_model(run_options=run_opt, model_options=jdata["model_options"], common_options=jdata["common_options"])
-
- # one can just add his own function to calculate properties by add a task, and its code to calculate.
-
- if task=='band':
- # TODO: add argcheck for bandstructure, with different options. see, kline_mode: ase, vasp, abacus, etc.
- bcal = bandcalc(apiHrk, run_opt, task_options)
- bcal.get_bands()
- bcal.band_plot()
- log.info(msg='band calculation successfully completed.')
-
- if task=='dos':
- bcal = doscalc(apiHrk, run_opt, task_options)
- bcal.get_dos()
- bcal.dos_plot()
- log.info(msg='dos calculation successfully completed.')
-
- if task=='pdos':
- bcal = pdoscalc(apiHrk, run_opt, task_options)
- bcal.get_pdos()
- bcal.pdos_plot()
- log.info(msg='pdos calculation successfully completed.')
+# # one can just add his own function to calculate properties by add a task, and its code to calculate.
+# if task=='band':
+# # TODO: add argcheck for bandstructure, with different options. see, kline_mode: ase, vasp, abacus, etc.
+# bcal = bandcalc(model, structure, task_options)
+# bcal.get_bands()
+# bcal.band_plot()
+# log.info(msg='band calculation successfully completed.')
+
+# if task=='dos':
+# bcal = doscalc(model, structure, task_options)
+# bcal.get_dos()
+# bcal.dos_plot()
+# log.info(msg='dos calculation successfully completed.')
+
+# if task=='pdos':
+# bcal = pdoscalc(model, structure, task_options)
+# bcal.get_pdos()
+# bcal.pdos_plot()
+# log.info(msg='pdos calculation successfully completed.')
- if task=='FS2D':
- fs2dcal = fs2dcalc(apiHrk, run_opt, task_options)
- fs2dcal.get_fs()
- fs2dcal.fs2d_plot()
- log.info(msg='2dFS calculation successfully completed.')
+# if task=='FS2D':
+# fs2dcal = fs2dcalc(model, structure, task_options)
+# fs2dcal.get_fs()
+# fs2dcal.fs2d_plot()
+# log.info(msg='2dFS calculation successfully completed.')
- if task == 'FS3D':
- fs3dcal = fs3dcalc(apiHrk, run_opt, task_options)
- fs3dcal.get_fs()
- fs3dcal.fs_plot()
- log.info(msg='3dFS calculation successfully completed.')
+# if task == 'FS3D':
+# fs3dcal = fs3dcalc(model, structure, task_options)
+# fs3dcal.get_fs()
+# fs3dcal.fs_plot()
+# log.info(msg='3dFS calculation successfully completed.')
- if task == 'ifermi':
- if not(ifermi_installed and pymatgen_installed):
- log.error(msg="ifermi and pymatgen are required to perform ifermi calculation !")
- raise RuntimeError
-
- ifermi = ifermiapi(apiHrk, run_opt, task_options)
- bs = ifermi.get_band_structure()
- fs = ifermi.get_fs(bs)
- ifermi.fs_plot(fs)
- log.info(msg='Ifermi calculation successfully completed.')
- if task == 'write_sk':
- if not run_sk:
- raise RuntimeError("write_sk can only perform on nnsk model !")
- write_sk = WriteNNSKParam(apiHrk, run_opt, task_options)
- write_sk.write()
- log.info(msg='write_sk calculation successfully completed.')
-
- if task == 'negf':
- negf = NEGF(apiHrk, run_opt, task_options)
- negf.compute()
- log.info(msg='NEGF calculation successfully completed.')
-
- if task == 'tbtrans_negf':
- if not(sisl_installed):
- log.error(msg="sisl is required to perform tbtrans calculation !")
- raise RuntimeError
-
- tbtrans_init = TBTransInputSet(apiHrk, run_opt, task_options)
- tbtrans_init.hamil_get_write(write_nc=True)
- log.info(msg='TBtrans input files are successfully generated.')
-
- if output:
- with open(os.path.join(output, "run_config.json"), "w") as fp:
- if jdata.get("common_options", None):
- jdata["common_options"]["dtype"] = str_dtype
- json.dump(jdata, fp, indent=4)
+# if task == 'ifermi':
+# if not(ifermi_installed and pymatgen_installed):
+# log.error(msg="ifermi and pymatgen are required to perform ifermi calculation !")
+# raise RuntimeError
+
+# ifermi = ifermiapi(model, structure, task_options)
+# bs = ifermi.get_band_structure()
+# fs = ifermi.get_fs(bs)
+# ifermi.fs_plot(fs)
+# log.info(msg='Ifermi calculation successfully completed.')
+# if task == 'write_sk':
+# if not jdata["model_options"].keys()[0] == "nnsk" or len(jdata["model_options"].keys()) > 1:
+# raise RuntimeError("write_sk can only perform on nnsk model !")
+# write_sk = WriteNNSKParam(model, structure, task_options)
+# write_sk.write()
+# log.info(msg='write_sk calculation successfully completed.')
+
+# if task == 'negf':
+# negf = NEGF(model, structure, task_options)
+# negf.compute()
+# log.info(msg='NEGF calculation successfully completed.')
+
+# if task == 'tbtrans_negf':
+# if not(sisl_installed):
+# log.error(msg="sisl is required to perform tbtrans calculation !")
+# raise RuntimeError
+
+# tbtrans_init = TBTransInputSet(apiHrk, run_opt, task_options)
+# tbtrans_init.hamil_get_write(write_nc=True)
+# log.info(msg='TBtrans input files are successfully generated.')
+
+# if output:
+# with open(os.path.join(output, "run_config.json"), "w") as fp:
+# json.dump(jdata, fp, indent=4)
diff --git a/dptb/entrypoints/test.py b/dptb/entrypoints/test.py
index 7380ef8c..9874f7b3 100644
--- a/dptb/entrypoints/test.py
+++ b/dptb/entrypoints/test.py
@@ -1,21 +1,16 @@
import heapq
import logging
import torch
-import random
import json
import os
import time
-import numpy as np
from pathlib import Path
-from dptb.nnops.tester_dptb import DPTBTester
-from dptb.nnops.tester_nnsk import NNSKTester
-from typing import Dict, List, Optional, Any
+from dptb.nn.build import build_model
+from dptb.data.build import build_dataset
+from typing import Optional
from dptb.utils.loggers import set_log_handles
from dptb.utils.tools import j_loader, setup_seed
-from dptb.utils.constants import dtype_dict
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.plugins.init_dptb import InitDPTBModel
-from dptb.plugins.init_data import InitTestData
+from dptb.nnops.tester import Tester
from dptb.utils.argcheck import normalize_test
from dptb.plugins.monitor import TestLossMonitor
from dptb.plugins.train_logger import Logger
@@ -30,7 +25,6 @@ def _test(
output: str,
log_level: int,
log_path: Optional[str],
- test_sk: bool,
use_correction: Optional[str],
**kwargs
):
@@ -39,98 +33,11 @@ def _test(
"init_model": init_model,
"log_path": log_path,
"log_level": log_level,
- "test_sk": test_sk,
"use_correction": use_correction,
"freeze":True,
"train_soc":False
}
- if all((use_correction, test_sk)):
- log.error(msg="--use-correction and --train_sk should not be set at the same time")
- raise RuntimeError
-
- # setup INPUT path
- if test_sk:
- if init_model:
- skconfig_path = os.path.join(str(Path(init_model).parent.absolute()), "config_nnsktb.json")
- mode = "init_model"
- else:
- log.error("ValueError: Missing init_model file path.")
- raise ValueError
- jdata = j_loader(INPUT)
- jdata = normalize_test(jdata)
-
- if all((jdata["init_model"]["path"], run_opt["init_model"])):
- raise RuntimeError(
- "init-model in config and command line is in conflict, turn off one of then to avoid this error !"
- )
- else:
- if jdata["init_model"]["path"] is not None:
- assert mode == "from_scratch"
- run_opt["init_model"] = jdata["init_model"]
- mode = "init_model"
- if isinstance(run_opt["init_model"]["path"], str):
- skconfig_path = os.path.join(str(Path(run_opt["init_model"]["path"]).parent.absolute()), "config_nnsktb.json")
- else: # list
- skconfig_path = [os.path.join(str(Path(path).parent.absolute()), "config_nnsktb.json") for path in run_opt["init_model"]["path"]]
- else:
- if run_opt["init_model"] is not None:
- assert mode == "init_model"
- path = run_opt["init_model"]
- run_opt["init_model"] = jdata["init_model"]
- run_opt["init_model"]["path"] = path
- else:
- if init_model:
- dptbconfig_path = os.path.join(str(Path(init_model).parent.absolute()), "config_dptbtb.json")
- mode = "init_model"
- else:
- log.error("ValueError: Missing init_model file path.")
- raise ValueError
-
- if use_correction:
- skconfig_path = os.path.join(str(Path(use_correction).parent.absolute()), "config_nnsktb.json")
- else:
- skconfig_path = None
-
- jdata = j_loader(INPUT)
- jdata = normalize_test(jdata)
-
- if all((jdata["init_model"]["path"], run_opt["init_model"])):
- raise RuntimeError(
- "init-model in config and command line is in conflict, turn off one of then to avoid this error !"
- )
-
- if jdata["init_model"]["path"] is not None:
- assert mode == "from_scratch"
- log.info(msg="Init model is read from config rile.")
- run_opt["init_model"] = jdata["init_model"]
- mode = "init_model"
- if isinstance(run_opt["init_model"]["path"], str):
- dptbconfig_path = os.path.join(str(Path(run_opt["init_model"]["path"]).parent.absolute()), "config_dptb.json")
- else: # list
- raise RuntimeError(
- "loading lists of checkpoints is only supported in init_nnsk!"
- )
- elif run_opt["init_model"] is not None:
- assert mode == "init_model"
- path = run_opt["init_model"]
- run_opt["init_model"] = jdata["init_model"]
- run_opt["init_model"]["path"] = path
-
- if mode == "init_model":
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"])==0:
- log.error(msg="Error, no checkpoint supplied!")
- raise RuntimeError
- elif len(run_opt["init_model"]["path"])>1:
- log.error(msg="Error! list mode init_model in config only support single file in DPTB!")
- raise RuntimeError
-
- if mode == "init_model":
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"]) == 1:
- run_opt["init_model"]["path"] = run_opt["init_model"]["path"][0]
-
# setup output path
if output:
Path(output).parent.mkdir(exist_ok=True, parents=True)
@@ -146,42 +53,38 @@ def _test(
"results_path": str(Path(results_path).absolute()),
"log_path": str(Path(log_path).absolute())
})
- run_opt.update({"mode": mode})
- if test_sk:
- run_opt.update({
- "skconfig_path": skconfig_path,
- })
- else:
- if use_correction:
- run_opt.update({
- "skconfig_path": skconfig_path
- })
- run_opt.update({
- "dptbconfig_path": dptbconfig_path
- })
-
- set_log_handles(log_level, Path(log_path) if log_path else None)
+
+ jdata = j_loader(INPUT)
+ jdata = normalize_test(jdata)
+ # setup seed
+ setup_seed(seed=jdata["common_options"]["seed"])
- # setup_seed(seed=jdata["train_options"]["seed"])
+ f = torch.load(init_model)
+ # update basis
+ basis = f["config"]["common_options"]["basis"]
+ for asym, orb in jdata["common_options"]["basis"].items():
+ assert asym in basis.keys(), f"Atom {asym} not found in model's basis"
+ assert orb == basis[asym], f"Orbital {orb} of Atom {asym} not consistent with the model's basis"
+ jdata["common_options"]["basis"] = basis # use the old basis, because it will be used to build the orbital mapper for dataset
- # with open(os.path.join(output, "test_config.json"), "w") as fp:
- # json.dump(jdata, fp, indent=4)
-
+ set_log_handles(log_level, Path(log_path) if log_path else None)
- str_dtype = jdata["common_options"]["dtype"]
- jdata["common_options"]["dtype"] = dtype_dict[jdata["common_options"]["dtype"]]
+ f = torch.load(run_opt["init_model"])
+ jdata["model_options"] = f["config"]["model_options"]
+ del f
+ test_datasets = build_dataset(set_options=jdata["data_options"]["test"], common_options=jdata["common_options"])
+ model = build_model(run_options=run_opt, model_options=jdata["model_options"], common_options=jdata["common_options"])
+ model.eval()
+ tester = Tester(
+ test_options=jdata["test_options"],
+ common_options=jdata["common_options"],
+ model = model,
+ test_datasets=test_datasets,
+ )
- if test_sk:
- tester = NNSKTester(run_opt, jdata)
- tester.register_plugin(InitSKModel())
- else:
- tester = DPTBTester(run_opt, jdata)
- tester.register_plugin(InitDPTBModel())
-
# register the plugin in tester, to tract training info
- tester.register_plugin(InitTestData())
tester.register_plugin(TestLossMonitor())
tester.register_plugin(Logger(["test_loss"],
interval=[(1, 'iteration'), (1, 'epoch')]))
@@ -194,20 +97,12 @@ def _test(
if output:
# output training configurations:
with open(os.path.join(output, "test_config.json"), "w") as fp:
- jdata["common_options"]["dtype"] = str_dtype
json.dump(jdata, fp, indent=4)
- #tester.register_plugin(Saver(
- #interval=[(jdata["train_options"].get("save_freq"), 'epoch'), (1, 'iteration')] if jdata["train_options"].get(
- # "save_freq") else None))
- # interval=[(jdata["train_options"].get("save_freq"), 'iteration'), (1, 'epoch')] if jdata["train_options"].get(
- # "save_freq") else None))
- # add a plugin to save the training parameters of the model, with model_output as given path
-
start_time = time.time()
- tester.run(epochs=1)
+ tester.run()
end_time = time.time()
log.info("finished testing")
- log.info(f"wall time: {(end_time - start_time):.3f} s")
+ log.info(f"wall time: {(end_time - start_time):.3f} s")
\ No newline at end of file
diff --git a/dptb/entrypoints/train.py b/dptb/entrypoints/train.py
index b1be08a3..d58b6710 100644
--- a/dptb/entrypoints/train.py
+++ b/dptb/entrypoints/train.py
@@ -1,14 +1,12 @@
-from dptb.nnops.train_dptb import DPTBTrainer
-from dptb.nnops.train_nnsk import NNSKTrainer
+from dptb.nnops.trainer import Trainer
+from dptb.nn.build import build_model
+from dptb.data.build import build_dataset
from dptb.plugins.monitor import TrainLossMonitor, LearningRateMonitor, Validationer
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.plugins.init_dptb import InitDPTBModel
-from dptb.plugins.init_data import InitData
from dptb.plugins.train_logger import Logger
from dptb.utils.argcheck import normalize
from dptb.plugins.plugins import Saver
from typing import Dict, List, Optional, Any
-from dptb.utils.tools import j_loader, setup_seed
+from dptb.utils.tools import j_loader, setup_seed, j_must_have
from dptb.utils.constants import dtype_dict
from dptb.utils.loggers import set_log_handles
import heapq
@@ -30,30 +28,24 @@ def train(
INPUT: str,
init_model: Optional[str],
restart: Optional[str],
- freeze:bool,
train_soc:bool,
output: str,
log_level: int,
log_path: Optional[str],
- train_sk: bool,
- use_correction: Optional[str],
**kwargs
):
run_opt = {
"init_model": init_model,
"restart": restart,
- "freeze": freeze,
"train_soc": train_soc,
"log_path": log_path,
- "log_level": log_level,
- "train_sk": train_sk,
- "use_correction": use_correction
+ "log_level": log_level
}
+ assert train_soc is False, "train_soc is not supported yet"
+
'''
-1- set up input and output directories
- noticed that, the checkpoint of sktb and dptb should be in different directory, and in train_dptb,
- there should be a workflow to load correction model from nnsktb.
-2- parse configuration file and start training
output directories has following structure:
@@ -65,132 +57,18 @@ def train(
...
- log/
- log.log
- - config_nnsktb.json
- - config_dptb.json
+ - config.json
'''
# init all paths
# if init_model, restart or init_frez, findout the input configure file
-
- if all((use_correction, train_sk)):
- raise RuntimeError(
- "--use-correction and --train_sk should not be set at the same time"
- )
# setup INPUT path
- if train_sk:
- if init_model:
- skconfig_path = os.path.join(str(Path(init_model).parent.absolute()), "config_nnsktb.json")
- mode = "init_model"
- elif restart:
- skconfig_path = os.path.join(str(Path(restart).parent.absolute()), "config_nnsktb.json")
- mode = "restart"
- elif INPUT is not None:
- log.info(msg="Haven't assign a initializing mode, training from scratch as default.")
- mode = "from_scratch"
- skconfig_path = INPUT
- else:
- log.error("ValueError: Missing Input configuration file path.")
- raise ValueError
-
- # switch the init model mode from command line to config file
- jdata = j_loader(INPUT)
- jdata = normalize(jdata)
-
- # check if init_model in commandline and input json are in conflict.
-
- if all((jdata["init_model"]["path"], run_opt["init_model"])) or \
- all((jdata["init_model"]["path"], run_opt["restart"])):
- raise RuntimeError(
- "init-model in config and command line is in conflict, turn off one of then to avoid this error !"
- )
-
- if jdata["init_model"]["path"] is not None:
- assert mode == "from_scratch"
- run_opt["init_model"] = jdata["init_model"]
- mode = "init_model"
- if isinstance(run_opt["init_model"]["path"], str):
- skconfig_path = os.path.join(str(Path(run_opt["init_model"]["path"]).parent.absolute()), "config_nnsktb.json")
- else: # list
- skconfig_path = [os.path.join(str(Path(path).parent.absolute()), "config_nnsktb.json") for path in run_opt["init_model"]["path"]]
- elif run_opt["init_model"] is not None:
- # format run_opt's init model to the format of jdata
- assert mode == "init_model"
- path = run_opt["init_model"]
- run_opt["init_model"] = jdata["init_model"]
- run_opt["init_model"]["path"] = path
-
- # handling exceptions when init_model path in config file is [] and [single file]
- if mode == "init_model":
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"])==0:
- raise RuntimeError("Error! list mode init_model in config file cannot be empty!")
-
- else:
- if init_model:
- dptbconfig_path = os.path.join(str(Path(init_model).parent.absolute()), "config_dptbtb.json")
- mode = "init_model"
- elif restart:
- dptbconfig_path = os.path.join(str(Path(restart).parent.absolute()), "config_dptbtb.json")
- mode = "restart"
- elif INPUT is not None:
- log.info(msg="Haven't assign a initializing mode, training from scratch as default.")
- dptbconfig_path = INPUT
- mode = "from_scratch"
- else:
- log.error("ValueError: Missing Input configuration file path.")
- raise ValueError
-
- if use_correction:
- skconfig_path = os.path.join(str(Path(use_correction).parent.absolute()), "config_nnsktb.json")
- # skcheckpoint_path = str(Path(str(input(f"Enter skcheckpoint_path (default ./checkpoint/best_nnsk.pth): \n"))).absolute())
- else:
- skconfig_path = None
-
- # parse INPUT file
- jdata = j_loader(INPUT)
- jdata = normalize(jdata)
-
- if all((jdata["init_model"]["path"], run_opt["init_model"])) or \
- all((jdata["init_model"]["path"], run_opt["restart"])):
- raise RuntimeError(
- "init-model in config and command line is in conflict, turn off one of then to avoid this error !"
- )
-
- if jdata["init_model"]["path"] is not None:
- assert mode == "from_scratch"
- log.info(msg="Init model is read from config rile.")
- run_opt["init_model"] = jdata["init_model"]
- mode = "init_model"
- if isinstance(run_opt["init_model"]["path"], str):
- dptbconfig_path = os.path.join(str(Path(run_opt["init_model"]["path"]).parent.absolute()), "config_dptb.json")
- else: # list
- raise RuntimeError(
- "loading lists of checkpoints is only supported in init_nnsk!"
- )
- elif run_opt["init_model"] is not None:
- assert mode == "init_model"
- path = run_opt["init_model"]
- run_opt["init_model"] = jdata["init_model"]
- run_opt["init_model"]["path"] = path
-
- if mode == "init_model":
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"])==0:
- log.error(msg="Error, no checkpoint supplied!")
- raise RuntimeError
- elif len(run_opt["init_model"]["path"])>1:
- log.error(msg="Error! list mode init_model in config only support single file in DPTB!")
- raise RuntimeError
if all((run_opt["init_model"], restart)):
raise RuntimeError(
"--init-model and --restart should not be set at the same time"
)
- if mode == "init_model":
- if isinstance(run_opt["init_model"]["path"], list):
- if len(run_opt["init_model"]["path"]) == 1:
- run_opt["init_model"]["path"] = run_opt["init_model"]["path"][0]
# setup output path
if output:
Path(output).parent.mkdir(exist_ok=True, parents=True)
@@ -209,71 +87,137 @@ def train(
"log_path": str(Path(log_path).absolute())
})
- run_opt.update({"mode": mode})
- if train_sk:
- run_opt.update({
- "skconfig_path": skconfig_path,
- })
- else:
- if use_correction:
- run_opt.update({
- "skconfig_path": skconfig_path
- })
- run_opt.update({
- "dptbconfig_path": dptbconfig_path
- })
-
set_log_handles(log_level, Path(log_path) if log_path else None)
# parse the config. Since if use init, config file may not equals to current
+ jdata = j_loader(INPUT)
+ jdata = normalize(jdata)
+ # update basis if init_model or restart
+ # update jdata
+ # this is not necessary, because if we init model from checkpoint, the build_model will load the model_options from checkpoints if not provided
+ # since here we want to output jdata as a config file to inform the user what model options are used, we need to update the jdata
+ torch.set_default_dtype(getattr(torch, jdata["common_options"]["dtype"]))
+
+ if restart or init_model:
+ f = restart if restart else init_model
+ f = torch.load(f)
+
+ if jdata.get("model_options", None) is None:
+ jdata["model_options"] = f["config"]["model_options"]
+
+ # update basis
+ basis = f["config"]["common_options"]["basis"]
+ # nnsk
+ if len(f["config"]["model_options"])==1 and f["config"]["model_options"].get("nnsk") != None:
+ for asym, orb in jdata["common_options"]["basis"].items():
+ assert asym in basis.keys(), f"Atom {asym} not found in model's basis"
+ if orb != basis[asym]:
+ log.info(f"Initializing Orbital {orb} of Atom {asym} from {basis[asym]}")
+ # we have the orbitals in jdata basis correct, now we need to make sure all atom in basis are also contained in jdata basis
+ for asym, orb in basis.items():
+ if asym not in jdata["common_options"]["basis"].keys():
+ jdata["common_options"]["basis"][asym] = orb # add the atomtype in the checkpoint but not in the jdata basis, because it will be used to build the orbital mapper for dataset
+ else: # not nnsk
+ for asym, orb in jdata["common_options"]["basis"].items():
+ assert asym in basis.keys(), f"Atom {asym} not found in model's basis"
+ assert orb == basis[asym], f"Orbital {orb} of Atom {asym} not consistent with the model's basis, which is only allowed in nnsk training"
+
+ jdata["common_options"]["basis"] = basis
+
+ # update model options and train_options
+ if restart:
+ #
+ if jdata.get("train_options", None) is not None:
+ for obj in Trainer.object_keys:
+ if jdata["train_options"].get(obj) != f["config"]["train_options"].get(obj):
+ log.warning(f"{obj} in config file is not consistent with the checkpoint, using the one in checkpoint")
+ jdata["train_options"][obj] = f["config"]["train_options"][obj]
+ else:
+ jdata["train_options"] = f["config"]["train_options"]
+
+ if jdata.get("model_options", None) is None or jdata["model_options"] != f["config"]["model_options"]:
+ log.warning("model_options in config file is not consistent with the checkpoint, using the one in checkpoint")
+ jdata["model_options"] = f["config"]["model_options"] # restart does not allow to change model options
+ else:
+ # init model mode, allow model_options change
+ if jdata.get("train_options", None) is None:
+ jdata["train_options"] = f["config"]["train_options"]
+ if jdata.get("model_options") is None:
+ jdata["model_options"] = f["config"]["model_options"]
+ del f
+ else:
+ j_must_have(jdata, "model_options")
+ j_must_have(jdata, "train_options")
+
+
# setup seed
- setup_seed(seed=jdata["train_options"]["seed"])
+ setup_seed(seed=jdata["common_options"]["seed"])
# with open(os.path.join(output, "train_config.json"), "w") as fp:
# json.dump(jdata, fp, indent=4)
-
- str_dtype = jdata["common_options"]["dtype"]
- jdata["common_options"]["dtype"] = dtype_dict[jdata["common_options"]["dtype"]]
- if train_sk:
- trainer = NNSKTrainer(run_opt, jdata)
- trainer.register_plugin(InitSKModel())
+
+ # build dataset
+ train_datasets = build_dataset(set_options=jdata["data_options"]["train"], common_options=jdata["common_options"])
+ if jdata["data_options"].get("validation"):
+ validation_datasets = build_dataset(set_options=jdata["data_options"]["validation"], common_options=jdata["common_options"])
else:
- trainer = DPTBTrainer(run_opt, jdata)
- trainer.register_plugin(InitDPTBModel())
-
-
+ validation_datasets = None
+ if jdata["data_options"].get("reference"):
+ reference_datasets = build_dataset(set_options=jdata["data_options"]["reference"], common_options=jdata["common_options"])
+ else:
+ reference_datasets = None
+
+ if restart:
+ trainer = Trainer.restart(
+ train_options=jdata["train_options"],
+ common_options=jdata["common_options"],
+ checkpoint=restart,
+ train_datasets=train_datasets,
+ reference_datasets=reference_datasets,
+ validation_datasets=validation_datasets,
+ )
+ else:
+ # include the init model and from scratch
+ # build model will handle the init model cases where the model options provided is not equals to the ones in checkpoint.
+ model = build_model(run_options=run_opt, model_options=jdata["model_options"], common_options=jdata["common_options"], statistics=train_datasets.E3statistics())
+ trainer = Trainer(
+ train_options=jdata["train_options"],
+ common_options=jdata["common_options"],
+ model = model,
+ train_datasets=train_datasets,
+ validation_datasets=validation_datasets,
+ reference_datasets=reference_datasets,
+ )
# register the plugin in trainer, to tract training info
- trainer.register_plugin(InitData())
- trainer.register_plugin(Validationer())
+ log_field = ["train_loss", "lr"]
+ if validation_datasets:
+ trainer.register_plugin(Validationer())
+ log_field.append("validation_loss")
trainer.register_plugin(TrainLossMonitor())
trainer.register_plugin(LearningRateMonitor())
- trainer.register_plugin(Logger(["train_loss", "validation_loss", "lr"],
+ trainer.register_plugin(Logger(log_field,
interval=[(jdata["train_options"]["display_freq"], 'iteration'), (1, 'epoch')]))
for q in trainer.plugin_queues.values():
heapq.heapify(q)
-
- trainer.build()
-
if output:
# output training configurations:
with open(os.path.join(output, "train_config.json"), "w") as fp:
- jdata["common_options"]["dtype"] = str_dtype
json.dump(jdata, fp, indent=4)
trainer.register_plugin(Saver(
#interval=[(jdata["train_options"].get("save_freq"), 'epoch'), (1, 'iteration')] if jdata["train_options"].get(
# "save_freq") else None))
interval=[(jdata["train_options"].get("save_freq"), 'iteration'), (1, 'epoch')] if jdata["train_options"].get(
- "save_freq") else None))
+ "save_freq") else None), checkpoint_path=checkpoint_path)
# add a plugin to save the training parameters of the model, with model_output as given path
start_time = time.time()
- trainer.run(trainer.num_epoch)
+ trainer.run(trainer.train_options["num_epoch"])
end_time = time.time()
log.info("finished training")
diff --git a/dptb/hamiltonian/hamil_eig_sk.py b/dptb/hamiltonian/hamil_eig_sk.py
deleted file mode 100644
index d73e7435..00000000
--- a/dptb/hamiltonian/hamil_eig_sk.py
+++ /dev/null
@@ -1,278 +0,0 @@
-import torch
-import torch as th
-import numpy as np
-import logging
-import re
-from dptb.hamiltonian.transform_sk import RotationSK
-from dptb.utils.constants import anglrMId
-
-''' Over use of different index system cause the symbols and type and index kind of object need to be recalculated in different
-Class, this makes entanglement of classes difficult. Need to design an consistent index system to resolve.'''
-
-log = logging.getLogger(__name__)
-
-class HamilEig(RotationSK):
- """ This module is to build the Hamiltonian from the SK-type bond integral.
- """
- def __init__(self, dtype='tensor') -> None:
- super().__init__(rot_type=dtype)
- self.dtype = dtype
- self.use_orthogonal_basis = False
- self.hamil_blocks = None
- self.overlap_blocks = None
-
- def update_hs_list(self, struct, hoppings, onsiteEs, overlaps=None, onsiteSs=None, **options):
- '''It updates the bond structure, bond type, bond type id, bond hopping, bond onsite, hopping, onsite
- energy, overlap, and onsite spin
-
- Parameters
- ----------
- hoppings
- a list bond integral for hoppings.
- onsiteEs
- a list of onsite energy for each atom and each orbital.
- overlaps
- a list bond integral for overlaps.
- onsiteSs
- a list of onsite overlaps for each atom and each orbital.
- '''
- self.__struct__ = struct
- self.hoppings = hoppings
- self.onsiteEs = onsiteEs
- self.use_orthogonal_basis = False
- if overlaps is None:
- self.use_orthogonal_basis = True
- else:
- self.overlaps = overlaps
- self.onsiteSs = onsiteSs
- self.use_orthogonal_basis = False
-
- self.num_orbs_per_atom = []
- for itype in self.__struct__.proj_atom_symbols:
- norbs = self.__struct__.proj_atomtype_norbs[itype]
- self.num_orbs_per_atom.append(norbs)
-
- def get_hs_blocks(self, bonds_onsite = None, bonds_hoppings=None):
- """using the SK type bond integral to build the hamiltonian matrix and overlap matrix in the real space.
-
- The hamiltonian and overlap matrix block are stored in the order of bond list. for ecah bond ij, with lattice
- vecto R, the matrix stored in [norbsi, norbsj]. norsbi and norbsj are the total number of orbtals on i and j sites.
- e.g. for C-atom with both s and p orbital on each site. norbi is 4.
- """
- if bonds_onsite is None:
- bonds_onsite = self.__struct__.__bonds_onsite__
- assert len(bonds_onsite) == len(self.__struct__.__bonds_onsite__)
- if bonds_hoppings is None:
- bonds_hoppings = self.__struct__.__bonds__
- assert len(bonds_hoppings) == len(self.__struct__.__bonds__)
-
- hamil_blocks = []
- if not self.use_orthogonal_basis:
- overlap_blocks = []
- for ib in range(len(bonds_onsite)):
- ibond = bonds_onsite[ib].astype(int)
- iatype = self.__struct__.proj_atom_symbols[ibond[1]]
- jatype = self.__struct__.proj_atom_symbols[ibond[3]]
- assert iatype == jatype, "i type should equal j type."
-
- if self.dtype == 'tensor':
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- if not self.use_orthogonal_basis:
- sub_over_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- else:
- sub_hamil_block = np.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- if not self.use_orthogonal_basis:
- sub_over_block = np.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
-
- # ToDo: adding onsite correction
- ist = 0
- # replace sub_hamil_block from now the block diagonal formula to corrected ones.
- for ish in self.__struct__.proj_atom_anglr_m[iatype]: # ['s','p',..]
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol] # 0,1,2,...
- norbi = 2*shidi + 1
-
- indx = self.__struct__.onsite_index_map[iatype][ish] # change onsite index map from {N:{s:}} to {N:{ss:, sp:}}
- # this already satisfy for uniform onsite or splited onsite energy.
- # e.g. for p orbital, index may be 1, or 1,2,3, stands for uniform or splited energy for px py pz.
- # and then self.onsiteEs[ib][indx] can be scalar or torch.Size([1]) or torch.Size([3]).
- # both of them can be transfer into a [3x3] diagonal matrix in this code.
- if self.dtype == 'tensor':
- sub_hamil_block[ist:ist+norbi, ist:ist+norbi] = th.eye(norbi) * self.onsiteEs[ib][indx]
- if not self.use_orthogonal_basis:
- sub_over_block[ist:ist+norbi, ist:ist+norbi] = th.eye(norbi) * self.onsiteSs[ib][indx]
- else:
- sub_hamil_block[ist:ist+norbi, ist:ist+norbi] = np.eye(norbi) * self.onsiteEs[ib][indx]
- if not self.use_orthogonal_basis:
- sub_over_block[ist:ist+norbi, ist:ist+norbi] = np.eye(norbi) * self.onsiteSs[ib][indx]
- ist = ist +norbi
-
- hamil_blocks.append(sub_hamil_block)
- if not self.use_orthogonal_basis:
- overlap_blocks.append(sub_over_block)
-
- for ib in range(len(bonds_hoppings)):
-
- ibond = bonds_hoppings[ib,0:7].astype(int)
- #direction_vec = (self.__struct__.projected_struct.positions[ibond[3]]
- # - self.__struct__.projected_struct.positions[ibond[1]]
- # + np.dot(ibond[4:], self.__struct__.projected_struct.cell))
- #dist = np.linalg.norm(direction_vec)
- #direction_vec = direction_vec/dist
- direction_vec = bonds_hoppings[ib,8:11].astype(np.float32)
- iatype = self.__struct__.proj_atom_symbols[ibond[1]]
- jatype = self.__struct__.proj_atom_symbols[ibond[3]]
-
- if self.dtype == 'tensor':
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- if not self.use_orthogonal_basis:
- sub_over_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- else:
- sub_hamil_block = np.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
- if not self.use_orthogonal_basis:
- sub_over_block = np.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]])
-
- bondatomtype = iatype + '-' + jatype
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol]
- norbi = 2*shidi+1
-
- jst = 0
- for jsh in self.__struct__.proj_atom_anglr_m[jatype]:
- jshsymbol = ''.join(re.findall(r'[A-Za-z]',jsh))
- shidj = anglrMId[jshsymbol]
- norbj = 2 * shidj + 1
-
- idx = self.__struct__.bond_index_map[bondatomtype][ish+'-'+jsh]
- if shidi < shidj:
- tmpH = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- # Hamilblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
- if self.dtype == 'tensor':
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpH,dim0=0,dim1=1)
- else:
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * np.transpose(tmpH,(1,0))
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.overlaps[ib][idx], Angvec=direction_vec)
- # Soverblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpS,dim0=0,dim1=1)
- if self.dtype == 'tensor':
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpS,dim0=0,dim1=1)
- else:
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * np.transpose(tmpS,(1,0))
- else:
- tmpH = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = tmpH
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue = self.overlaps[ib][idx], Angvec = direction_vec)
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = tmpS
-
- jst = jst + norbj
- ist = ist + norbi
- hamil_blocks.append(sub_hamil_block)
- if not self.use_orthogonal_basis:
- overlap_blocks.append(sub_over_block)
- self.all_bonds = np.concatenate([bonds_onsite[:,0:7],bonds_hoppings[:,0:7]],axis=0)
- self.all_bonds = self.all_bonds.astype(int)
- self.hamil_blocks = hamil_blocks
- if not self.use_orthogonal_basis:
- self.overlap_blocks = overlap_blocks
-
-
- def hs_block_R2k(self, kpoints, HorS='H', time_symm=True, dtype='tensor'):
- '''The function takes in a list of Hamiltonian matrices for each bond, and a list of k-points, and
- returns a list of Hamiltonian matrices for each k-point
-
- Parameters
- ----------
- HorS
- string, 'H' or 'S' to indicate for Hk or Sk calculation.
- kpoints
- the k-points in the path.
- time_symm, optional
- if True, the Hamiltonian is time-reversal symmetric, defaults to True (optional)
- dtype, optional
- 'tensor' or 'numpy', defaults to tensor (optional)
-
- Returns
- -------
- A list of Hamiltonian or Overlap matrices for each k-point.
- '''
- numOrbs = np.array(self.num_orbs_per_atom)
- totalOrbs = np.sum(numOrbs)
- if HorS == 'H':
- hijAll = self.hamil_blocks
- elif HorS == 'S':
- hijAll = self.overlap_blocks
- else:
- print("HorS should be 'H' or 'S' !")
-
- if dtype == 'tensor':
- Hk = th.zeros([len(kpoints), totalOrbs, totalOrbs], dtype = th.complex64)
- else:
- Hk = np.zeros([len(kpoints), totalOrbs, totalOrbs], dtype = np.complex64)
-
- for ik in range(len(kpoints)):
- k = kpoints[ik]
- if dtype == 'tensor':
- hk = th.zeros([totalOrbs,totalOrbs],dtype = th.complex64)
- else:
- hk = np.zeros([totalOrbs,totalOrbs],dtype = np.complex64)
- for ib in range(len(self.all_bonds)):
- Rlatt = self.all_bonds[ib,4:7].astype(int)
- i = self.all_bonds[ib,1].astype(int)
- j = self.all_bonds[ib,3].astype(int)
- ist = int(np.sum(numOrbs[0:i]))
- ied = int(np.sum(numOrbs[0:i+1]))
- jst = int(np.sum(numOrbs[0:j]))
- jed = int(np.sum(numOrbs[0:j+1]))
- if ib < len(numOrbs):
- """
- len(numOrbs)= numatoms. the first numatoms are onsite energies.
- if turn on timeSymm when generating the bond list . only i>= or <= j are included.
- if turn off timeSymm when generating the bond list . all the i j are included.
- for case 1, H = H+H^\dagger to get the full matrix, the the onsite one is doubled.
- for case 2. no need to do H = H+H^dagger. since the matrix is already full.
- """
- if time_symm:
- hk[ist:ied,jst:jed] += 0.5 * hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- else:
- hk[ist:ied,jst:jed] += hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- else:
- hk[ist:ied,jst:jed] += hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- if time_symm:
- hk = hk + hk.T.conj()
- Hk[ik] = hk
- return Hk
-
- def Eigenvalues(self, kpoints, time_symm=True,dtype='tensor'):
- """ using the tight-binding H and S matrix calculate eigenvalues at kpoints.
-
- Args:
- kpoints: the k-kpoints used to calculate the eigenvalues.
- Note: must have the BondHBlock and BondSBlock
- """
- hkmat = self.hs_block_R2k(kpoints=kpoints, HorS='H', time_symm=time_symm, dtype=dtype)
- if not self.use_orthogonal_basis:
- skmat = self.hs_block_R2k(kpoints=kpoints, HorS='S', time_symm=time_symm, dtype=dtype)
- else:
- skmat = torch.eye(hkmat.shape[1], dtype=torch.complex64).unsqueeze(0).repeat(hkmat.shape[0], 1, 1)
-
- if self.dtype == 'tensor':
- chklowt = th.linalg.cholesky(skmat)
- chklowtinv = th.linalg.inv(chklowt)
- Heff = (chklowtinv @ hkmat @ th.transpose(chklowtinv,dim0=1,dim1=2).conj())
- # the factor 13.605662285137 * 2 from Hartree to eV.
- # eigks = th.linalg.eigvalsh(Heff) * 13.605662285137 * 2
- eigks, Q = th.linalg.eigh(Heff)
- eigks = eigks * 13.605662285137 * 2
- Qres = Q.detach()
- else:
- chklowt = np.linalg.cholesky(skmat)
- chklowtinv = np.linalg.inv(chklowt)
- Heff = (chklowtinv @ hkmat @ np.transpose(chklowtinv,(0,2,1)).conj())
- eigks = np.linalg.eigvalsh(Heff) * 13.605662285137 * 2
- Qres = 0
-
- return eigks, Qres
\ No newline at end of file
diff --git a/dptb/hamiltonian/hamil_eig_sk_crt_soc.py b/dptb/hamiltonian/hamil_eig_sk_crt_soc.py
deleted file mode 100644
index 19493c18..00000000
--- a/dptb/hamiltonian/hamil_eig_sk_crt_soc.py
+++ /dev/null
@@ -1,395 +0,0 @@
-import torch
-import torch as th
-import numpy as np
-import logging
-import re
-from dptb.hamiltonian.transform_sk import RotationSK
-from dptb.nnsktb.formula import SKFormula
-from dptb.utils.constants import anglrMId
-from dptb.hamiltonian.soc import creat_basis_lm, get_soc_matrix_cubic_basis
-
-''' Over use of different index system cause the symbols and type and index kind of object need to be recalculated in different
-Class, this makes entanglement of classes difficult. Need to design an consistent index system to resolve.'''
-
-log = logging.getLogger(__name__)
-
-class HamilEig(RotationSK):
- """ This module is to build the Hamiltonian from the SK-type bond integral.
- """
- def __init__(self, dtype=torch.float32, device='cpu') -> None:
- super().__init__(rot_type=dtype, device=device)
- self.dtype = dtype
- if self.dtype is th.float32:
- self.cdtype = th.complex64
- elif self.dtype is th.float64:
- self.cdtype = th.complex128
- self.use_orthogonal_basis = False
- self.hamil_blocks = None
- self.overlap_blocks = None
- self.device = device
-
- def update_hs_list(self, struct, hoppings, onsiteEs, onsiteVs=None, overlaps=None, onsiteSs=None, soc_lambdas=None, **options):
- '''It updates the bond structure, bond type, bond type id, bond hopping, bond onsite, hopping, onsite
- energy, overlap, and onsite spin
-
- Parameters
- ----------
- hoppings
- a list bond integral for hoppings.
- onsiteEs
- a list of onsite energy for each atom and each orbital.
- overlaps
- a list bond integral for overlaps.
- onsiteSs
- a list of onsite overlaps for each atom and each orbital.
- '''
- self.__struct__ = struct
- self.hoppings = hoppings
- self.onsiteEs = onsiteEs
- self.onsiteVs = onsiteVs
- self.soc_lambdas = soc_lambdas
- self.use_orthogonal_basis = False
- if overlaps is None:
- self.use_orthogonal_basis = True
- else:
- self.overlaps = overlaps
- self.onsiteSs = onsiteSs
- self.use_orthogonal_basis = False
-
- if soc_lambdas is None:
- self.soc = False
- else:
- self.soc = True
-
- self.num_orbs_per_atom = []
- for itype in self.__struct__.proj_atom_symbols:
- norbs = self.__struct__.proj_atomtype_norbs[itype]
- self.num_orbs_per_atom.append(norbs)
-
- def get_soc_block(self, bonds_onsite = None):
- numOrbs = np.array(self.num_orbs_per_atom)
- totalOrbs = np.sum(numOrbs)
- if bonds_onsite is None:
- _, bonds_onsite = self.__struct__.get_bond()
-
- soc_upup = torch.zeros_like((totalOrbs, totalOrbs), device=self.device, dtype=self.cdtype)
- soc_updown = torch.zeros_like((totalOrbs, totalOrbs), device=self.device, dtype=self.cdtype)
-
- # compute soc mat for each atom:
- soc_atom_upup = self.__struct__.get("soc_atom_diag", {})
- soc_atom_updown = self.__struct__.get("soc_atom_up", {})
- if not soc_atom_upup or not soc_atom_updown:
- for iatype in self.__struct__.proj_atomtype:
- total_num_orbs_iatom= self.__struct__.proj_atomtype_norbs[iatype]
- tmp_upup = torch.zeros([total_num_orbs_iatom, total_num_orbs_iatom], dtype=self.cdtype, device=self.device)
- tmp_updown = torch.zeros([total_num_orbs_iatom, total_num_orbs_iatom], dtype=self.cdtype, device=self.device)
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol] # 0,1,2,...
- norbi = 2*shidi + 1
-
- soc_orb = get_soc_matrix_cubic_basis(orbital=ishsymbol, device=self.device, dtype=self.dtype)
- if len(soc_orb) != 2*norbi:
- log.error(msg='The dimension of the soc_orb is not correct!')
- tmp_upup[ist:ist+norbi, ist:ist+norbi] = soc_orb[:norbi,:norbi]
- tmp_updown[ist:ist+norbi, ist:ist+norbi] = soc_orb[:norbi, norbi:]
- ist = ist + norbi
-
- soc_atom_upup.update({iatype:tmp_upup})
- soc_atom_updown.update({iatype:tmp_updown})
- self.__struct__.soc_atom_upup = soc_atom_upup
- self.__struct__.soc_atom_updown = soc_atom_updown
-
- for ib in range(len(bonds_onsite)):
- ibond = bonds_onsite[ib].astype(int)
- iatom = ibond[1]
- ist = int(np.sum(numOrbs[0:iatom]))
- ied = int(np.sum(numOrbs[0:iatom+1]))
- iatype = self.__struct__.proj_atom_symbols[iatom]
-
- # get lambdas
- ist = 0
- lambdas = torch.zeros((ied-ist,), device=self.device, dtype=self.dtype)
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- indx = self.__struct__.onsite_index_map[iatype][ish]
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol] # 0,1,2,...
- norbi = 2*shidi + 1
- lambdas[ist:ist+norbi] = self.soc_lambdas[ib][indx]
- ist = ist + norbi
-
- soc_upup[ist:ied,ist:ied] = soc_atom_upup[iatype] * torch.diag(lambdas)
- soc_updown[ist:ied, ist:ied] = soc_atom_updown[iatype] * torch.diag(lambdas)
-
- soc_upup.contiguous()
- soc_updown.contiguous()
-
- return soc_upup, soc_updown
-
- def get_hs_onsite(self, bonds_onsite = None, onsite_envs=None):
- if bonds_onsite is None:
- _, bonds_onsite = self.__struct__.get_bond()
- onsiteH_blocks = []
- if not self.use_orthogonal_basis:
- onsiteS_blocks = []
- else:
- onsiteS_blocks = None
-
- iatom_to_onsite_index = {}
- for ib in range(len(bonds_onsite)):
- ibond = bonds_onsite[ib].astype(int)
- iatom = ibond[1]
- iatom_to_onsite_index.update({iatom:ib})
- jatom = ibond[3]
- iatype = self.__struct__.proj_atom_symbols[iatom]
- jatype = self.__struct__.proj_atom_symbols[jatom]
- assert iatype == jatype, "i type should equal j type."
-
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
- if not self.use_orthogonal_basis:
- sub_over_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]: # ['s','p',..]
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol] # 0,1,2,...
- norbi = 2*shidi + 1
-
- indx = self.__struct__.onsite_index_map[iatype][ish] # change onsite index map from {N:{s:}} to {N:{ss:, sp:}}
- sub_hamil_block[ist:ist+norbi, ist:ist+norbi] = th.eye(norbi, dtype=self.dtype, device=self.device) * self.onsiteEs[ib][indx]
- if not self.use_orthogonal_basis:
- sub_over_block[ist:ist+norbi, ist:ist+norbi] = th.eye(norbi, dtype=self.dtype, device=self.device) * self.onsiteSs[ib][indx]
- ist = ist + norbi
-
- onsiteH_blocks.append(sub_hamil_block)
- if not self.use_orthogonal_basis:
- onsiteS_blocks.append(sub_over_block)
-
- # onsite strain
- if onsite_envs is not None:
- assert self.onsiteVs is not None
- for ib, env in enumerate(onsite_envs):
-
- iatype, iatom, jatype, jatom = self.__struct__.proj_atom_symbols[int(env[1])], env[1], self.__struct__.atom_symbols[int(env[3])], env[3]
- direction_vec = env[8:11].astype(np.float32)
-
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[iatype]], dtype=self.dtype, device=self.device)
-
- envtype = iatype + '-' + jatype
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol]
- norbi = 2*shidi+1
-
- jst = 0
- for jsh in self.__struct__.proj_atom_anglr_m[iatype]:
- jshsymbol = ''.join(re.findall(r'[A-Za-z]',jsh))
- shidj = anglrMId[jshsymbol]
- norbj = 2 * shidj + 1
-
- idx = self.__struct__.onsite_strain_index_map[envtype][ish+'-'+jsh]
-
- if shidi < shidj:
-
- tmpH = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.onsiteVs[ib][idx], Angvec=direction_vec)
- # Hamilblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
- else:
- tmpH = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue=self.onsiteVs[ib][idx], Angvec=direction_vec)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = tmpH
-
- jst = jst + norbj
- ist = ist + norbi
- onsiteH_blocks[iatom_to_onsite_index[iatom]] += sub_hamil_block
-
- return onsiteH_blocks, onsiteS_blocks, bonds_onsite
-
- def get_hs_hopping(self, bonds_hoppings = None):
- if bonds_hoppings is None:
- bonds_hoppings, _ = self.__struct__.get_bond()
-
- hoppingH_blocks = []
- if not self.use_orthogonal_basis:
- hoppingS_blocks = []
- else:
- hoppingS_blocks = None
-
- for ib in range(len(bonds_hoppings)):
-
- ibond = bonds_hoppings[ib,0:7].astype(int)
- #direction_vec = (self.__struct__.projected_struct.positions[ibond[3]]
- # - self.__struct__.projected_struct.positions[ibond[1]]
- # + np.dot(ibond[4:], self.__struct__.projected_struct.cell))
- #dist = np.linalg.norm(direction_vec)
- #direction_vec = direction_vec/dist
- direction_vec = bonds_hoppings[ib,8:11].astype(np.float32)
- iatype = self.__struct__.proj_atom_symbols[ibond[1]]
- jatype = self.__struct__.proj_atom_symbols[ibond[3]]
-
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
- if not self.use_orthogonal_basis:
- sub_over_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
-
- bondatomtype = iatype + '-' + jatype
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol]
- norbi = 2*shidi+1
-
- jst = 0
- for jsh in self.__struct__.proj_atom_anglr_m[jatype]:
- jshsymbol = ''.join(re.findall(r'[A-Za-z]',jsh))
- shidj = anglrMId[jshsymbol]
- norbj = 2 * shidj + 1
-
- idx = self.__struct__.bond_index_map[bondatomtype][ish+'-'+jsh]
- if shidi < shidj:
- tmpH = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- # Hamilblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpH,dim0=0,dim1=1)
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.overlaps[ib][idx], Angvec=direction_vec)
- # Soverblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpS,dim0=0,dim1=1)
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpS,dim0=0,dim1=1)
- else:
- tmpH = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = tmpH
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue = self.overlaps[ib][idx], Angvec = direction_vec)
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = tmpS
-
- jst = jst + norbj
- ist = ist + norbi
-
- hoppingH_blocks.append(sub_hamil_block)
- if not self.use_orthogonal_basis:
- hoppingS_blocks.append(sub_over_block)
-
- return hoppingH_blocks, hoppingS_blocks, bonds_hoppings
-
- def get_hs_blocks(self, bonds_onsite = None, bonds_hoppings=None, onsite_envs=None):
- onsiteH, onsiteS, bonds_onsite = self.get_hs_onsite(bonds_onsite=bonds_onsite, onsite_envs=onsite_envs)
- hoppingH, hoppingS, bonds_hoppings = self.get_hs_hopping(bonds_hoppings=bonds_hoppings)
-
- self.all_bonds = np.concatenate([bonds_onsite[:,0:7],bonds_hoppings[:,0:7]],axis=0)
- self.all_bonds = self.all_bonds.astype(int)
- onsiteH.extend(hoppingH)
- self.hamil_blocks = onsiteH
- if not self.use_orthogonal_basis:
- onsiteS.extend(hoppingS)
- self.overlap_blocks = onsiteS
- if self.soc:
- self.soc_upup, self.soc_updown = self.get_soc_block(bonds_onsite=bonds_onsite)
-
- return True
-
- def hs_block_R2k(self, kpoints, HorS='H', time_symm=True):
- '''The function takes in a list of Hamiltonian matrices for each bond, and a list of k-points, and
- returns a list of Hamiltonian matrices for each k-point
-
- Parameters
- ----------
- HorS
- string, 'H' or 'S' to indicate for Hk or Sk calculation.
- kpoints
- the k-points in the path.
- time_symm, optional
- if True, the Hamiltonian is time-reversal symmetric, defaults to True (optional)
- dtype, optional
- 'tensor' or 'numpy', defaults to tensor (optional)
-
- Returns
- -------
- A list of Hamiltonian or Overlap matrices for each k-point.
- '''
-
- numOrbs = np.array(self.num_orbs_per_atom)
- totalOrbs = np.sum(numOrbs)
- if HorS == 'H':
- hijAll = self.hamil_blocks
- elif HorS == 'S':
- hijAll = self.overlap_blocks
- else:
- print("HorS should be 'H' or 'S' !")
-
- if self.soc:
- Hk = th.zeros([len(kpoints), 2*totalOrbs, 2*totalOrbs], dtype = self.cdtype, device=self.device)
- else:
- Hk = th.zeros([len(kpoints), totalOrbs, totalOrbs], dtype = self.cdtype, device=self.device)
-
- for ik in range(len(kpoints)):
- k = kpoints[ik]
- hk = th.zeros([totalOrbs,totalOrbs],dtype = self.cdtype, device=self.device)
- for ib in range(len(self.all_bonds)):
- Rlatt = self.all_bonds[ib,4:7].astype(int)
- i = self.all_bonds[ib,1].astype(int)
- j = self.all_bonds[ib,3].astype(int)
- ist = int(np.sum(numOrbs[0:i]))
- ied = int(np.sum(numOrbs[0:i+1]))
- jst = int(np.sum(numOrbs[0:j]))
- jed = int(np.sum(numOrbs[0:j+1]))
- if ib < len(numOrbs):
- """
- len(numOrbs)= numatoms. the first numatoms are onsite energies.
- if turn on timeSymm when generating the bond list . only i>= or <= j are included.
- if turn off timeSymm when generating the bond list . all the i j are included.
- for case 1, H = H+H^\dagger to get the full matrix, the the onsite one is doubled.
- for case 2. no need to do H = H+H^dagger. since the matrix is already full.
- """
- if time_symm:
- hk[ist:ied,jst:jed] += 0.5 * hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- else:
- hk[ist:ied,jst:jed] += hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- else:
- hk[ist:ied,jst:jed] += hijAll[ib] * np.exp(-1j * 2 * np.pi* np.dot(k,Rlatt))
- if time_symm:
- hk = hk + hk.T.conj()
- if self.soc:
- hk = torch.kron(A=torch.eye(2, device=self.device, dtype=self.dtype), B=hk)
- Hk[ik] = hk
-
- if self.soc:
- Hk[:, :totalOrbs, :totalOrbs] += self.soc_upup.unsqueeze(0)
- Hk[:, totalOrbs:, totalOrbs:] += self.soc_upup.conj().unsqueeze(0)
- Hk[:, :totalOrbs, totalOrbs:] += self.soc_updown.unsqueeze(0)
- Hk[:, totalOrbs:, :totalOrbs] += self.soc_updown.conj().unsqueeze(0)
-
- Hk.contiguous()
-
- return Hk
-
- def Eigenvalues(self, kpoints, time_symm=True):
- """ using the tight-binding H and S matrix calculate eigenvalues at kpoints.
-
- Args:
- kpoints: the k-kpoints used to calculate the eigenvalues.
- Note: must have the BondHBlock and BondSBlock
- """
- hkmat = self.hs_block_R2k(kpoints=kpoints, HorS='H', time_symm=time_symm)
- if not self.use_orthogonal_basis:
- skmat = self.hs_block_R2k(kpoints=kpoints, HorS='S', time_symm=time_symm)
- else:
- skmat = torch.eye(hkmat.shape[1], dtype=self.cdtype).unsqueeze(0).repeat(hkmat.shape[0], 1, 1)
-
- chklowt = th.linalg.cholesky(skmat)
- chklowtinv = th.linalg.inv(chklowt)
- Heff = (chklowtinv @ hkmat @ th.transpose(chklowtinv,dim0=1,dim1=2).conj())
- # the factor 13.605662285137 * 2 from Hartree to eV.
- # eigks = th.linalg.eigvalsh(Heff) * 13.605662285137 * 2
- eigks, Q = th.linalg.eigh(Heff)
- eigks = eigks * 13.605662285137 * 2
- Qres = Q.detach()
- # else:
- # chklowt = np.linalg.cholesky(skmat)
- # chklowtinv = np.linalg.inv(chklowt)
- # Heff = (chklowtinv @ hkmat @ np.transpose(chklowtinv,(0,2,1)).conj())
- # eigks = np.linalg.eigvalsh(Heff) * 13.605662285137 * 2
- # Qres = 0
-
- return eigks, Qres
\ No newline at end of file
diff --git a/dptb/nn/__init__.py b/dptb/nn/__init__.py
new file mode 100644
index 00000000..4aa0820a
--- /dev/null
+++ b/dptb/nn/__init__.py
@@ -0,0 +1,140 @@
+from .build import build_model
+from .deeptb import DPTB
+from .nnsk import NNSK
+
+__all__ = [
+ build_model,
+ DPTB,
+ NNSK,
+]
+"""
+
+nn module is the model class for the graph neural network model, which is the core of the deeptb package.
+It provide two interfaces which is used to interact with other module:
+1. The build_model method, which is used to construct a model based on the model_options, common_options and run_options.
+ - the model options decides the structure of the model, such as the number of layers, the activation function, the number of neurons in each layer, etc.
+ - the common options contains some common parameters, such as the dtype, device, and the basis, which also related to the model
+ - the run options decide how to initialize the model. Whether it is from scratch, init from checkpoint, freeze or not, or whether to deploy it.
+ The build model method will return a model class and a config dict.
+
+2. A config dict of the model, which contains the essential information of the model to be initialized again.
+
+The build model method should composed of the following steps:
+1. process the configs from user input and the config from the checkpoint (if any).
+2. construct the model based on the configs.
+3. process the config dict for the output dict.
+
+The deeptb model can be constructed by the following steps (which have been conpacted in deeptb.py):
+1. choose the way to construct edge and atom embedding, either a descriptor, GNN or both.
+ - in: data with env and edge vectors, and atomic numbers
+ - out: data with edge and atom embedding
+ - user view: this can be defined as a tag in model_options
+2. constructing the prediction layer, which named as sktb layer or e3tb layer, it is either a linear layer or a neural network
+ - in: data with edge and atom embedding
+ - out: data with the e3 irreducible matrix element, or the sk parameters
+3. constructing hamiltonian model, either a SKTB or E3TB
+ - in: data with properties/parameters predicted
+ - out data with SK/E3 hamiltonian
+
+model_options = {
+ "embedding": {
+ "mode":"se2/gnn/se3...",
+ # mode specific
+ # se2
+ "env_cutoff": 3.5,
+ "rs": float,
+ "rc": float,
+ "n_axis": int,
+ "radial_embedding": {
+ "neurons": [int],
+ "activation": str,
+ "if_batch_normalized": bool
+ }
+ # gnn
+ # se3
+ },
+ "prediction": {
+ "mode": "linear/nn",
+ # linear
+ # nn
+ "neurons": [int],
+ "activation": str,
+ "if_batch_normalized": bool,
+ "hamiltonian" = {
+ "method": "sktb/e3tb",
+ "rmax": 3.5,
+ "precision": float, # use to check if rmax is large enough
+ "soc": bool,
+ "overlap": bool,
+ # sktb
+ # e3tb
+ },
+ },
+ "nnsk":{
+ "hopping_function": {
+ "formula": "varTang96/powerlaw/NRL",
+ ...
+ },
+ "onsite_function": {
+ "formula": "strain/uniform/NRL",
+ # strain
+ "strain_cutoff": float,
+ # NRL
+ "cutoff": float,
+ "decay_w": float,
+ "lambda": float
+ }
+ }
+}
+"""
+
+common_options = {
+ "basis": {
+ "B": "2s2p1d",
+ "N": "2s2p1d",
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "r_max": 2.0,
+ "er_max": 4.0,
+ "oer_max": 6.0,
+}
+
+
+data_options = {
+ "train": {
+
+ }
+}
+
+
+dptb_model_options = {
+ "embedding": {
+ "method": "se2",
+ "rs": 2.0,
+ "rc": 7.0,
+ "n_axis": 10,
+ "radial_embedding": {
+ "neurons": [128,128,20],
+ "activation": "tanh",
+ "if_batch_normalized": False,
+ },
+ },
+ "prediction":{
+ "method": "nn",
+ "neurons": [256,256,256],
+ "activation": "tanh",
+ "if_batch_normalized": False,
+ "quantities": ["hamiltonian"],
+ "hamiltonian":{
+ "method": "e3tb",
+ "precision": 1e-5,
+ "overlap": False,
+ },
+ },
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":6.0, "w":0.1},
+ "hopping": {"method": "powerlaw", "rs":3.2, "w": 0.15},
+ "overlap": False
+ }
+}
\ No newline at end of file
diff --git a/dptb/nn/base.py b/dptb/nn/base.py
new file mode 100644
index 00000000..a11e0172
--- /dev/null
+++ b/dptb/nn/base.py
@@ -0,0 +1,464 @@
+from torch.nn import Linear
+import torch
+from dptb.data import AtomicDataDict
+from typing import Optional, Any, Union, Callable, OrderedDict, List
+from torch import Tensor
+from dptb.utils.constants import dtype_dict
+from dptb.utils.tools import _get_activation_fn
+import torch.nn.functional as F
+import torch.nn as nn
+
+class AtomicLinear(torch.nn.Module):
+ def __init__(
+ self,
+ in_features: int,
+ out_features: int,
+ in_field = AtomicDataDict.NODE_FEATURES_KEY,
+ out_field = AtomicDataDict.NODE_FEATURES_KEY,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu")
+ ):
+ super(AtomicLinear, self).__init__()
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+ self.linear = Linear(in_features, out_features, dtype=dtype, device=device)
+ self.in_field = in_field
+ self.out_field = out_field
+
+ def forward(self, data: AtomicDataDict.Type):
+ data[self.out_field] = self.linear(data[self.in_field])
+ return data
+
+class Identity(torch.nn.Module):
+ def __init__(
+ self,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ super(Identity, self).__init__()
+
+ def forward(self, data: AtomicDataDict) -> AtomicDataDict:
+ return data
+
+
+class AtomicMLP(torch.nn.Module):
+ def __init__(
+ self,
+ in_features,
+ hidden_features,
+ out_features,
+ in_field = AtomicDataDict.NODE_FEATURES_KEY,
+ out_field = AtomicDataDict.NODE_FEATURES_KEY,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized: bool = False,
+ device: Union[str, torch.device] = torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32
+ ):
+ super(AtomicMLP, self).__init__()
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+ self.in_layer = Linear(
+ in_features=in_features,
+ out_features=hidden_features,
+ device=device,
+ dtype=dtype)
+
+ self.out_layer = Linear(
+ in_features=hidden_features,
+ out_features=out_features,
+ device=device,
+ dtype=dtype)
+
+ if if_batch_normalized:
+ self.bn1 = torch.nn.BatchNorm1d(hidden_features)
+ self.bn2 = torch.nn.BatchNorm1d(out_features)
+ self.if_batch_normalized = if_batch_normalized
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ self.in_field = in_field
+ self.out_field = out_field
+
+ def __setstate__(self, state):
+ if 'activation' not in state:
+ state['activation'] = F.relu
+ super(AtomicMLP, self).__setstate__(state)
+
+ def forward(self, data: AtomicDataDict.Type):
+ x = self.in_layer(data[self.in_field])
+ if self.if_batch_normalized:
+ x = self.bn1(x)
+ x = self.activation(x)
+ x = self.out_layer(x)
+ if self.if_batch_normalized:
+ x = self.bn2(x)
+ data[self.out_field] = x
+
+ return data
+
+class AtomicFFN(torch.nn.Module):
+ def __init__(
+ self,
+ config: List[dict],
+ in_field: AtomicDataDict.NODE_FEATURES_KEY,
+ out_field: AtomicDataDict.NODE_FEATURES_KEY,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized: bool = False,
+ device: Union[str, torch.device] = torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ **kwargs
+ ):
+ super(AtomicFFN, self).__init__()
+ self.layers = torch.nn.ModuleList([])
+ for kk in range(len(config)-1):
+ if kk == 0:
+ self.layers.append(
+ AtomicMLP(
+ **config[kk],
+ in_field=in_field,
+ out_field=out_field,
+ if_batch_normalized=if_batch_normalized,
+ activation=activation,
+ device=device,
+ dtype=dtype
+ )
+ )
+ else:
+ self.layers.append(
+ AtomicMLP(
+ **config[kk],
+ in_field=out_field,
+ out_field=out_field,
+ if_batch_normalized=if_batch_normalized,
+ activation=activation,
+ device=device,
+ dtype=dtype
+ )
+ )
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ if config[-1].get('hidden_features') is None:
+ self.out_layer = AtomicLinear(in_features=config[-1]['in_features'], out_features=config[-1]['out_features'], in_field=out_field, out_field=out_field, device=device, dtype=dtype)
+ else:
+ self.out_layer = AtomicMLP(**config[-1], in_field=out_field, out_field=out_field, if_batch_normalized=False, activation=activation, device=device, dtype=dtype)
+ self.out_field = out_field
+ self.in_field = in_field
+ # self.out_norm = nn.LayerNorm(config[-1]['out_features'], elementwise_affine=True)
+
+ def forward(self, data: AtomicDataDict.Type):
+ out_scale = self.out_scale(data[self.in_field])
+ out_shift = self.out_shift(data[self.in_field])
+ for layer in self.layers:
+ data = layer(data)
+ data[self.out_field] = self.activation(data[self.out_field])
+
+ data = self.out_layer(data)
+ # data[self.out_field] = self.out_norm(data[self.out_field])
+ return data
+
+
+class AtomicResBlock(torch.nn.Module):
+ def __init__(self,
+ in_features: int,
+ hidden_features: int,
+ out_features: int,
+ in_field = AtomicDataDict.NODE_FEATURES_KEY,
+ out_field = AtomicDataDict.NODE_FEATURES_KEY,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized: bool=False,
+ device: Union[str, torch.device] = torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32
+ ):
+
+ super(AtomicResBlock, self).__init__()
+ self.in_field = in_field
+ self.out_field = out_field
+ self.layer = AtomicMLP(in_features, hidden_features, out_features, in_field=in_field, out_field=out_field, if_batch_normalized=if_batch_normalized, device=device, dtype=dtype, activation=activation)
+ self.out_features = out_features
+ self.in_features = in_features
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ def __setstate__(self, state):
+ if 'activation' not in state:
+ state['activation'] = F.relu
+ super(AtomicResBlock, self).__setstate__(state)
+
+ def forward(self, data: AtomicDataDict.Type):
+ if self.in_features < self.out_features:
+ res = F.interpolate(data[self.in_field].unsqueeze(1), size=[self.out_features]).squeeze(1)
+ elif self.in_features == self.out_features:
+ res = data[self.in_field]
+ else:
+ res = F.adaptive_avg_pool1d(input=data[self.in_field], output_size=self.out_features)
+
+ data = self.layer(data)
+ data[self.out_field] = data[self.out_field] + res
+
+ data[self.out_field] = self.activation(data[self.out_field])
+
+ return data
+
+# The ResNet class is a neural network model that consists of multiple residual blocks and a final
+# output layer, with options for activation functions and batch normalization.
+
+class AtomicResNet(torch.nn.Module):
+ def __init__(
+ self,
+ config: List[dict],
+ in_field: AtomicDataDict.NODE_FEATURES_KEY,
+ out_field: AtomicDataDict.NODE_FEATURES_KEY,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized: bool = False,
+ device: Union[str, torch.device] = torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ **kwargs,
+ ):
+ """_summary_
+
+ Parameters
+ ----------
+ config : list
+ ep: config = [
+ {'in_features': 3, 'hidden_features': 4, 'out_features': 8},
+ {'in_features': 8, 'hidden_features': 6, 'out_features': 4}
+ ]
+ activation : _type_
+ _description_
+ if_batch_normalized : bool, optional
+ _description_, by default False
+ device : str, optional
+ _description_, by default 'cpu'
+ dtype : _type_, optional
+ _description_, by default torch.float32
+ """
+ super(AtomicResNet, self).__init__()
+ self.in_field = in_field
+ self.out_field = out_field
+ self.layers = torch.nn.ModuleList([])
+ for kk in range(len(config)-1):
+ # the first layer will take the in_field as key to take `data[in_field]` and output the out_field, data[out_field] = layer(data[in_field])
+ # the rest of the layers will take the out_field as key to take `data[out_field]` and output the out_field, data[out_field] = layer(data[out_field])
+ # That why we need to set the in_field and out_field for 1st layer and the rest of the layers.
+ if kk == 0:
+ self.layers.append(
+ AtomicResBlock(
+ **config[kk],
+ in_field=in_field,
+ out_field=out_field,
+ if_batch_normalized=if_batch_normalized,
+ activation=activation,
+ device=device,
+ dtype=dtype
+ )
+ )
+ else:
+ self.layers.append(
+ AtomicResBlock(
+ **config[kk],
+ in_field=out_field,
+ out_field=out_field,
+ if_batch_normalized=if_batch_normalized,
+ activation=activation,
+ device=device,
+ dtype=dtype
+ )
+ )
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+
+ if config[-1].get('hidden_feature') is None:
+ self.out_layer = AtomicLinear(in_features=config[-1]['in_features'], out_features=config[-1]['out_features'], in_field=out_field, out_field=out_field, device=device, dtype=dtype)
+ else:
+ self.out_layer = AtomicMLP(**config[-1], if_batch_normalized=False, in_field=in_field, out_field=out_field, activation=activation, device=device, dtype=dtype)
+ # self.out_norm = nn.LayerNorm(config[-1]['out_features'], elementwise_affine=True)
+
+ def forward(self, data: AtomicDataDict.Type):
+
+ for layer in self.layers:
+ data = layer(data)
+ data[self.out_field] = self.activation(data[self.out_field])
+ data = self.out_layer(data)
+ # data[self.out_field] = self.out_norm(data[self.out_field])
+ return data
+
+class MLP(nn.Module):
+ def __init__(
+ self,
+ in_features,
+ hidden_features,
+ out_features,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized=False,
+ device: Union[str, torch.device]=torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(MLP, self).__init__()
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ self.in_layer = nn.Linear(in_features=in_features, out_features=hidden_features, device=device, dtype=dtype)
+ self.out_layer = nn.Linear(in_features=hidden_features, out_features=out_features, device=device, dtype=dtype)
+
+ if if_batch_normalized:
+ self.bn1 = nn.BatchNorm1d(hidden_features)
+ self.bn2 = nn.BatchNorm1d(out_features)
+ self.if_batch_normalized = if_batch_normalized
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ def __setstate__(self, state):
+ if 'activation' not in state:
+ state['activation'] = F.relu
+ super(MLP, self).__setstate__(state)
+
+ def forward(self, x):
+ x = self.in_layer(x)
+ if self.if_batch_normalized:
+ x = self.bn1(x)
+ x = self.activation(x)
+ x = self.out_layer(x)
+ if self.if_batch_normalized:
+ x = self.bn2(x)
+
+ return x
+
+class FFN(nn.Module):
+ def __init__(
+ self,
+ config,
+ activation,
+ if_batch_normalized=False,
+ device: Union[str, torch.device]=torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ **kwargs
+ ):
+ super(FFN, self).__init__()
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ self.layers = nn.ModuleList([])
+ for kk in range(len(config)-1):
+ self.layers.append(MLP(**config[kk], if_batch_normalized=if_batch_normalized, activation=activation, device=device, dtype=dtype))
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ if config[-1].get('hidden_features') is None:
+ self.out_layer = nn.Linear(in_features=config[-1]['in_features'], out_features=config[-1]['out_features'], device=device, dtype=dtype)
+ # nn.init.normal_(self.out_layer.weight, mean=0, std=1e-3)
+ # nn.init.normal_(self.out_layer.bias, mean=0, std=1e-3)
+ else:
+ self.out_layer = MLP(**config[-1], if_batch_normalized=False, activation=activation, device=device, dtype=dtype)
+
+ def forward(self, x):
+ for layer in self.layers:
+ x = layer(x)
+ x = self.activation(x)
+
+ return self.out_layer(x)
+
+
+class ResBlock(torch.nn.Module):
+ def __init__(
+ self,
+ in_features,
+ hidden_features,
+ out_features,
+ activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+ if_batch_normalized=False,
+ device: Union[str, torch.device]=torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(ResBlock, self).__init__()
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ self.layer = MLP(in_features, hidden_features, out_features, if_batch_normalized=if_batch_normalized, device=device, dtype=dtype, activation=activation)
+ self.out_features = out_features
+ self.in_features = in_features
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+ def __setstate__(self, state):
+ pass
+ # super(ResBlock, self).__setstate__(state)
+
+ def forward(self, x):
+ out = self.layer(x)
+ if self.in_features < self.out_features:
+ out = nn.functional.interpolate(x.unsqueeze(1), size=[self.out_features]).squeeze(1) + out
+ elif self.in_features == self.out_features:
+ out = x + out
+ else:
+ out = nn.functional.adaptive_avg_pool1d(input=x, output_size=self.out_features) + out
+
+ out = self.activation(out)
+
+ return out
+
+class ResNet(torch.nn.Module):
+ def __init__(
+ self,
+ config,
+ activation,
+ if_batch_normalized=False,
+ device: Union[str, torch.device]=torch.device('cpu'),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ **kwargs
+ ):
+ super(ResNet, self).__init__()
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ self.layers = torch.nn.ModuleList([])
+ for kk in range(len(config)-1):
+ self.layers.append(ResBlock(**config[kk], if_batch_normalized=if_batch_normalized, activation=activation, device=device, dtype=dtype))
+ if isinstance(activation, str):
+ self.activation = _get_activation_fn(activation)
+ else:
+ self.activation = activation
+
+
+ if config[-1].get('hidden_features') is None:
+ self.out_layer = nn.Linear(in_features=config[-1]['in_features'], out_features=config[-1]['out_features'], device=device, dtype=dtype)
+ # nn.init.normal_(self.out_layer.weight, mean=0, std=1e-3)
+ # nn.init.normal_(self.out_layer.bias, mean=0, std=1e-3)
+ else:
+ self.out_layer = MLP(**config[-1], if_batch_normalized=False, activation=activation, device=device, dtype=dtype)
+
+ def forward(self, x):
+ for layer in self.layers:
+ x = layer(x)
+ x = self.activation(x)
+
+ return self.out_layer(x)
\ No newline at end of file
diff --git a/dptb/nn/build.py b/dptb/nn/build.py
new file mode 100644
index 00000000..3ab9fa46
--- /dev/null
+++ b/dptb/nn/build.py
@@ -0,0 +1,101 @@
+from dptb.nn.deeptb import DPTB, MIX
+import logging
+from dptb.nn.nnsk import NNSK
+import torch
+from dptb.utils.tools import j_must_have
+
+log = logging.getLogger(__name__)
+
+def build_model(run_options, model_options: dict={}, common_options: dict={}, statistics: dict=None):
+ """
+ The build model method should composed of the following steps:
+ 1. process the configs from user input and the config from the checkpoint (if any).
+ 2. construct the model based on the configs.
+ 3. process the config dict for the output dict.
+ run_opt = {
+ "init_model": init_model,
+ "restart": restart,
+ "freeze": freeze,
+ "log_path": log_path,
+ "log_level": log_level,
+ "use_correction": use_correction
+ }
+ """
+ # this is the
+ # process the model_options
+ assert not all((run_options.get("init_model"), run_options.get("restart"))), "You can only choose one of the init_model and restart options."
+ if any((run_options.get("init_model"), run_options.get("restart"))):
+ from_scratch = False
+ checkpoint = run_options.get("init_model") or run_options.get("restart")
+ else:
+ from_scratch = True
+ if not all((model_options, common_options)):
+ logging.error("You need to provide model_options and common_options when you are initializing a model from scratch.")
+ raise ValueError
+
+ # decide whether to initialize a mixed model, or a deeptb model, or a nnsk model
+ init_deeptb = False
+ init_nnsk = False
+ init_mixed = False
+
+ # load the model_options and common_options from checkpoint if not provided
+ if not from_scratch:
+ # init model from checkpoint
+ if len(model_options) == 0:
+ f = torch.load(checkpoint)
+ model_options = f["config"]["model_options"]
+ del f
+
+ if len(common_options) == 0:
+ f = torch.load(checkpoint)
+ common_options = f["config"]["common_options"]
+ del f
+
+ if all((all((model_options.get("embedding"), model_options.get("prediction"))), model_options.get("nnsk"))):
+ init_mixed = True
+ elif all((model_options.get("embedding"), model_options.get("prediction"))):
+ init_deeptb = True
+ elif model_options.get("nnsk"):
+ init_nnsk = True
+ else:
+ log.error("Model cannot be built without either one of the terms in model_options (embedding+prediction/nnsk).")
+ raise ValueError
+
+ assert int(init_mixed) + int(init_deeptb) + int(init_nnsk) == 1, "You can only choose one of the mixed, deeptb, and nnsk options."
+ # check if the model is deeptb or nnsk
+
+ # init deeptb
+ if from_scratch:
+ if init_deeptb:
+ model = DPTB(**model_options, **common_options)
+
+ # do initialization from statistics if DPTB is e3tb and statistics is provided
+ if model.method == "e3tb" and statistics is not None:
+ scalar_mask = torch.BoolTensor([ir.dim==1 for ir in model.idp.orbpair_irreps])
+ node_shifts = statistics["node"]["scalar_ave"]
+ node_scales = statistics["node"]["norm_ave"]
+ node_scales[:,scalar_mask] = statistics["node"]["scalar_std"]
+
+ edge_shifts = statistics["edge"]["scalar_ave"]
+ edge_scales = statistics["edge"]["norm_ave"]
+ edge_scales[:,scalar_mask] = statistics["edge"]["scalar_std"]
+ model.node_prediction_h.set_scale_shift(scales=node_scales, shifts=node_shifts)
+ model.edge_prediction_h.set_scale_shift(scales=edge_scales, shifts=edge_shifts)
+
+ if init_nnsk:
+ model = NNSK(**model_options["nnsk"], **common_options)
+
+ if init_mixed:
+ model = MIX(**model_options, **common_options)
+
+ else:
+ # load the model from the checkpoint
+ if init_deeptb:
+ model = DPTB.from_reference(checkpoint, **model_options, **common_options)
+ if init_nnsk:
+ model = NNSK.from_reference(checkpoint, **model_options["nnsk"], **common_options)
+ if init_mixed:
+ # mix model can be initilized with a mixed reference model or a nnsk model.
+ model = MIX.from_reference(checkpoint, **model_options, **common_options)
+
+ return model
diff --git a/dptb/nn/cutoff.py b/dptb/nn/cutoff.py
new file mode 100644
index 00000000..76b78014
--- /dev/null
+++ b/dptb/nn/cutoff.py
@@ -0,0 +1,55 @@
+import math
+import torch
+
+
+@torch.jit.script
+def cosine_cutoff(x: torch.Tensor, r_max: torch.Tensor, r_start_cos_ratio: float = 0.8):
+ """A piecewise cosine cutoff starting the cosine decay at r_decay_factor*r_max.
+
+ Broadcasts over r_max.
+ """
+ r_max, x = torch.broadcast_tensors(r_max.unsqueeze(-1), x.unsqueeze(0))
+ r_decay: torch.Tensor = r_start_cos_ratio * r_max
+ # for x < r_decay, clamps to 1, for x > r_max, clamps to 0
+ x = x.clamp(r_decay, r_max)
+ return 0.5 * (torch.cos((math.pi / (r_max - r_decay)) * (x - r_decay)) + 1.0)
+
+
+@torch.jit.script
+def polynomial_cutoff(
+ x: torch.Tensor, r_max: torch.Tensor, p: float = 6.0
+) -> torch.Tensor:
+ """Polynomial cutoff, as proposed in DimeNet: https://arxiv.org/abs/2003.03123
+
+
+ Parameters
+ ----------
+ r_max : tensor
+ Broadcasts over r_max.
+
+ p : int
+ Power used in envelope function
+ """
+ assert p >= 2.0
+ r_max, x = torch.broadcast_tensors(r_max.unsqueeze(-1), x.unsqueeze(0))
+ x = x / r_max
+
+ out = 1.0
+ out = out - (((p + 1.0) * (p + 2.0) / 2.0) * torch.pow(x, p))
+ out = out + (p * (p + 2.0) * torch.pow(x, p + 1.0))
+ out = out - ((p * (p + 1.0) / 2) * torch.pow(x, p + 2.0))
+
+ return out * (x < 1.0)
+
+@torch.jit.script
+def polynomial_cutoff2(
+ r: torch.Tensor, rc: torch.Tensor, rs: torch.Tensor,
+) -> torch.Tensor:
+
+ r_ = torch.zeros_like(r)
+ r_[r [{'in_features': 1, 'hidden_features': 2, 'out_features': 3},
+ {'in_features': 3, 'hidden_features': 4, 'out_features': 5},
+ {'in_features': 5, 'out_features': 6}]
+ [1, 2, 3, 4, 5] -> [{'in_features': 1, 'hidden_features': 2, 'out_features': 3},
+ {'in_features': 3, 'hidden_features': 4, 'out_features': 5}]
+ """
+
+ n = len(nl)
+ assert n > 1, "The neuron config should have at least 2 layers."
+ if n % 2 == 0:
+ d_out = nl[-1]
+ nl = nl[:-1]
+ config = []
+ for i in range(1,len(nl)-1, 2):
+ config.append({'in_features': nl[i-1], 'hidden_features': nl[i], 'out_features': nl[i+1]})
+
+ if n % 2 == 0:
+ config.append({'in_features': nl[-1], 'out_features': d_out})
+
+ return config
+
+class DPTB(nn.Module):
+ quantities = ["hamiltonian", "energy"]
+ name = "dptb"
+ def __init__(
+ self,
+ embedding: dict,
+ prediction: dict,
+ overlap: bool = False,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ transform: bool = True,
+ **kwargs,
+ ):
+
+ """The top level DeePTB model class.
+
+ Parameters
+ ----------
+ embedding_config : dict
+ _description_
+ prediction_config : dict
+ _description_
+ basis : Dict[str, Union[str, list], None], optional
+ _description_, by default None
+ idp : Union[OrbitalMapper, None], optional
+ _description_, by default None
+ transform : bool, optional
+ _description_, decide whether to transform the irreducible matrix element to the hamiltonians
+ dtype : Union[str, torch.dtype], optional
+ _description_, by default torch.float32
+ device : Union[str, torch.device], optional
+ _description_, by default torch.device("cpu")
+
+ Raises
+ ------
+ NotImplementedError
+ _description_
+ """
+ super(DPTB, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+ self.model_options = {"embedding": embedding.copy(), "prediction": prediction.copy()}
+ self.transform = transform
+
+
+ self.method = prediction.get("method", "e3tb")
+ # self.soc = prediction.get("soc", False)
+ self.prediction = prediction
+
+ prediction_copy = prediction.copy()
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method=self.method, device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_orbpair_maps()
+
+ n_species = len(self.basis.keys())
+ # initialize the embedding layer
+ self.embedding = Embedding(**embedding, dtype=dtype, device=device, idp=self.idp, n_atom=n_species)
+
+ # initialize the prediction layer
+
+ if self.method == "sktb":
+ prediction_copy["neurons"] = [self.embedding.out_node_dim] + prediction_copy["neurons"] + [self.idp.n_onsite_Es]
+ prediction_copy["config"] = get_neuron_config(prediction_copy["neurons"])
+
+ self.node_prediction_h = AtomicResNet(
+ **prediction_copy,
+ in_field=AtomicDataDict.NODE_FEATURES_KEY,
+ out_field=AtomicDataDict.NODE_FEATURES_KEY,
+ device=device,
+ dtype=dtype
+ )
+
+ prediction_copy["neurons"][0] = self.embedding.out_edge_dim
+ prediction_copy["neurons"][-1] = self.idp.reduced_matrix_element
+ prediction_copy["config"] = get_neuron_config(prediction_copy["neurons"])
+ self.edge_prediction_h = AtomicResNet(
+ **prediction_copy,
+ in_field=AtomicDataDict.EDGE_FEATURES_KEY,
+ out_field=AtomicDataDict.EDGE_FEATURES_KEY,
+ device=device,
+ dtype=dtype
+ )
+
+ if overlap:
+ self.edge_prediction_s = AtomicResNet(
+ **prediction_copy,
+ in_field=AtomicDataDict.EDGE_OVERLAP_KEY,
+ out_field=AtomicDataDict.EDGE_OVERLAP_KEY,
+ device=device,
+ dtype=dtype
+ )
+
+ elif prediction_copy.get("method") == "e3tb":
+ self.node_prediction_h = E3PerSpeciesScaleShift(
+ field=AtomicDataDict.NODE_FEATURES_KEY,
+ num_types=n_species,
+ irreps_in=self.embedding.out_node_irreps,
+ out_field = AtomicDataDict.NODE_FEATURES_KEY,
+ shifts=0.,
+ scales=1.,
+ dtype=self.dtype,
+ device=self.device,
+ **prediction_copy,
+ )
+
+ self.edge_prediction_h = E3PerEdgeSpeciesScaleShift(
+ field=AtomicDataDict.EDGE_FEATURES_KEY,
+ num_types=n_species,
+ irreps_in=self.embedding.out_edge_irreps,
+ out_field = AtomicDataDict.EDGE_FEATURES_KEY,
+ shifts=0.,
+ scales=1.,
+ dtype=self.dtype,
+ device=self.device,
+ **prediction_copy,
+ )
+ if overlap:
+ raise NotImplementedError("The overlap prediction is not implemented for e3tb method.")
+
+ else:
+ raise NotImplementedError("The prediction model {} is not implemented.".format(prediction_copy["method"]))
+
+
+ if self.method == "sktb":
+ self.hamiltonian = SKHamiltonian(
+ edge_field=AtomicDataDict.EDGE_FEATURES_KEY,
+ node_field=AtomicDataDict.NODE_FEATURES_KEY,
+ idp_sk=self.idp,
+ dtype=self.dtype,
+ device=self.device,
+ onsite=True,
+ )
+ if overlap:
+ self.overlap = SKHamiltonian(
+ idp_sk=self.idp,
+ edge_field=AtomicDataDict.EDGE_OVERLAP_KEY,
+ node_field=AtomicDataDict.NODE_OVERLAP_KEY,
+ dtype=self.dtype,
+ device=self.device,
+ onsite=False,
+ )
+
+ elif self.method == "e3tb":
+ self.hamiltonian = E3Hamiltonian(
+ edge_field=AtomicDataDict.EDGE_FEATURES_KEY,
+ node_field=AtomicDataDict.NODE_FEATURES_KEY,
+ idp=self.idp,
+ dtype=self.dtype,
+ device=self.device
+ )
+ if overlap:
+ self.overlap = E3Hamiltonian(
+ idp=self.idp,
+ edge_field=AtomicDataDict.EDGE_OVERLAP_KEY,
+ node_field=AtomicDataDict.NODE_OVERLAP_KEY,
+ dtype=self.dtype,
+ device=self.device,
+ overlap=True,
+ )
+
+
+ def forward(self, data: AtomicDataDict.Type):
+
+ data = self.embedding(data)
+ if hasattr(self, "overlap"):
+ data[AtomicDataDict.EDGE_OVERLAP_KEY] = data[AtomicDataDict.EDGE_FEATURES_KEY]
+
+ data = self.node_prediction_h(data)
+ data = self.edge_prediction_h(data)
+ if hasattr(self, "overlap"):
+ data = self.edge_prediction_s(data)
+
+ if self.transform:
+ data = self.hamiltonian(data)
+ if hasattr(self, "overlap"):
+ data = self.overlap(data)
+
+ return data
+
+ @classmethod
+ def from_reference(
+ cls,
+ checkpoint,
+ embedding: dict={},
+ prediction: dict={},
+ overlap: bool=None,
+ basis: Dict[str, Union[str, list]]=None,
+ dtype: Union[str, torch.dtype]=None,
+ device: Union[str, torch.device]=None,
+ transform: bool = True,
+ **kwargs
+ ):
+
+ ckpt = torch.load(checkpoint)
+ common_options = {
+ "dtype": dtype,
+ "device": device,
+ "basis": basis,
+ "overlap": overlap,
+ }
+
+ model_options = {
+ "embedding": embedding,
+ "prediction": prediction,
+ }
+
+ if len(embedding) == 0 or len(prediction) == 0:
+ model_options.update(ckpt["config"]["model_options"])
+
+ for k,v in common_options.items():
+ if v is None:
+ common_options[k] = ckpt["config"]["common_options"][k]
+
+ model = cls(**model_options, **common_options, transform=transform)
+ model.load_state_dict(ckpt["model_state_dict"])
+
+ del ckpt
+
+ return model
+
+class MIX(nn.Module):
+ name = "mix"
+ def __init__(
+ self,
+ embedding: dict,
+ prediction: dict,
+ nnsk: dict,
+ basis: Dict[str, Union[str, list]]=None,
+ overlap: bool = False,
+ idp_sk: Union[OrbitalMapper, None]=None,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+ super(MIX, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+
+ self.dtype = dtype
+ self.device = device
+
+ self.dptb = DPTB(
+ embedding=embedding,
+ prediction=prediction,
+ basis=basis,
+ idp=idp_sk,
+ overlap=overlap,
+ dtype=dtype,
+ device=device,
+ transform=False,
+ )
+
+ self.nnsk = NNSK(
+ basis=basis,
+ idp_sk=idp_sk,
+ **nnsk,
+ overlap=overlap,
+ dtype=dtype,
+ device=device,
+ transform=False,
+ )
+ self.idp = self.nnsk.idp
+
+ self.model_options = self.nnsk.model_options
+ self.model_options.update(self.dptb.model_options)
+
+ self.hamiltonian = self.nnsk.hamiltonian
+ if overlap:
+ self.overlap = self.nnsk.overlap
+
+
+
+ def forward(self, data: AtomicDataDict.Type):
+ data_dptb = self.dptb(data)
+ data_nnsk = self.nnsk(data)
+
+ data_nnsk[AtomicDataDict.EDGE_FEATURES_KEY] = data_nnsk[AtomicDataDict.EDGE_FEATURES_KEY] * (1 + data_dptb[AtomicDataDict.EDGE_FEATURES_KEY])
+ data_nnsk[AtomicDataDict.NODE_FEATURES_KEY] = data_nnsk[AtomicDataDict.NODE_FEATURES_KEY] * (1 + data_dptb[AtomicDataDict.NODE_FEATURES_KEY])
+
+ data_nnsk = self.hamiltonian(data_nnsk)
+ if hasattr(self, "overlap"):
+ data_nnsk = self.overlap(data_nnsk)
+
+ return data_nnsk
+
+ @classmethod
+ def from_reference(
+ cls,
+ checkpoint,
+ embedding: dict=None,
+ prediction: dict=None,
+ nnsk: dict=None,
+ basis: Dict[str, Union[str, list]]=None,
+ overlap: bool = None,
+ dtype: Union[str, torch.dtype] = None,
+ device: Union[str, torch.device] = None,
+ **kwargs,
+ ):
+ # the mapping from the parameters of the ref_model and the current model can be found using
+ # reference model's idp and current idp
+
+ ckpt = torch.load(checkpoint)
+ common_options = {
+ "dtype": dtype,
+ "device": device,
+ "basis": basis,
+ "overlap": overlap,
+ }
+ model_options = {
+ "embedding": embedding,
+ "prediction": prediction,
+ "nnsk": nnsk,
+ }
+
+ if len(nnsk) == 0:
+ model_options["nnsk"] = ckpt["config"]["model_options"]["nnsk"]
+
+ if len(embedding) == 0 or len(prediction) == 0:
+ assert ckpt["config"]["model_options"].get("embedding") is not None and ckpt["config"]["model_options"].get("prediction") is not None, \
+ "The reference model checkpoint should come from a mixed model if dptb info is not provided."
+
+ model_options["embedding"] = ckpt["config"]["model_options"]["embedding"]
+ model_options["prediction"] = ckpt["config"]["model_options"]["prediction"]
+
+ for k,v in common_options.items():
+ if v is None:
+ common_options[k] = ckpt["config"]["common_options"][k]
+
+ if ckpt["config"]["model_options"].get("embedding") is not None and ckpt["config"]["model_options"].get("prediction") is not None:
+ # read from mixed model
+ model = cls(**model_options, **common_options)
+ model.load_state_dict(ckpt["model_state_dict"])
+
+ else:
+ assert ckpt["config"]["model_options"].get("nnsk") is not None, "The referenced checkpoint should provide at least the nnsk model info."
+ # read from nnsk model
+
+ model = cls(**model_options, **common_options)
+ model.nnsk.load_state_dict(ckpt["model_state_dict"])
+
+ del ckpt
+
+ return model
\ No newline at end of file
diff --git a/dptb/nn/embedding/__init__.py b/dptb/nn/embedding/__init__.py
new file mode 100644
index 00000000..f271c7b6
--- /dev/null
+++ b/dptb/nn/embedding/__init__.py
@@ -0,0 +1,21 @@
+from .emb import Embedding
+from .se2 import SE2Descriptor
+from .baseline import BASELINE
+from .mpnn import MPNN
+from .deephe3 import E3DeePH
+from .e3baseline import E3BaseLineModel
+from .e3baseline_local import E3BaseLineModelLocal
+from .e3baseline_nonlocal import E3BaseLineModelNonLocal
+from .e3baseline_local1 import E3BaseLineModelLocal1
+from .e3baseline_nonlocal_wnode import E3BaseLineModelNonLocalWNODE
+
+__all__ = [
+ "Descriptor",
+ "SE2Descriptor",
+ "Identity",
+ "E3DeePH",
+ "E3BaseLineModelLocal",
+ "E3BaseLineModelLocal1",
+ "E3BaseLineModelNonLocal",
+ "E3BaseLineModelNonLocalWNODE",
+]
\ No newline at end of file
diff --git a/dptb/nn/embedding/allegro.py b/dptb/nn/embedding/allegro.py
new file mode 100644
index 00000000..05ea2ee6
--- /dev/null
+++ b/dptb/nn/embedding/allegro.py
@@ -0,0 +1,637 @@
+from typing import Optional, List, Union
+import math
+import functools
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from e3nn import o3
+from e3nn.o3 import TensorProduct, Linear
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+
+from dptb.data import AtomicDataDict
+from ..radial_basis import BesselBasis
+from dptb.nn.graph_mixin import GraphModuleMixin
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+import math
+
+from math import ceil
+
+@compile_mode("script")
+class Allegro_Module(GraphModuleMixin, torch.nn.Module):
+ # saved params
+ num_layers: int
+
+ field: str
+ out_field: str
+ num_types: int
+ env_embed_mul: int
+ weight_numel: int
+ latent_resnet: bool
+ embed_initial_edge: bool
+
+ # internal values
+ _env_builder_w_index: List[int]
+ _env_builder_n_irreps: int
+ _input_pad: int
+
+ def __init__(
+ self,
+ # required params
+ num_layers: int,
+ num_types: int,
+ r_max: float,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ per_layer_cutoffs: Optional[List[float]] = None,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ field: str = AtomicDataDict.EDGE_ATTRS_KEY,
+ edge_invariant_field: str = AtomicDataDict.EDGE_EMBEDDING_KEY,
+ node_invariant_field: str = AtomicDataDict.NODE_ATTRS_KEY,
+ env_embed_multiplicity: int = 32,
+ embed_initial_edge: bool = True,
+ linear_after_env_embed: bool = False,
+ nonscalars_include_parity: bool = True,
+ # MLP parameters:
+ two_body_latent=ScalarMLPFunction,
+ two_body_latent_kwargs={},
+ env_embed=ScalarMLPFunction,
+ env_embed_kwargs={},
+ latent=ScalarMLPFunction,
+ latent_kwargs={},
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ latent_out_field: Optional[str] = _keys.EDGE_FEATURES,
+ # Performance parameters:
+ pad_to_alignment: int = 1,
+ sparse_mode: Optional[str] = None,
+ # Other:
+ irreps_in=None,
+ ):
+ super().__init__()
+ SCALAR = o3.Irrep("0e") # define for convinience
+
+ # save parameters
+ assert (
+ num_layers >= 1
+ ) # zero layers is "two body", but we don't need to support that fallback case
+ self.num_layers = num_layers
+ self.nonscalars_include_parity = nonscalars_include_parity
+ self.field = field
+ self.latent_out_field = latent_out_field
+ self.edge_invariant_field = edge_invariant_field
+ self.node_invariant_field = node_invariant_field
+ self.latent_resnet = latent_resnet
+ self.env_embed_mul = env_embed_multiplicity
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = float(PolynomialCutoff_p)
+ self.cutoff_type = cutoff_type
+ assert cutoff_type in ("cosine", "polynomial")
+ self.embed_initial_edge = embed_initial_edge
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.num_types = num_types
+
+ # set up irreps
+ self._init_irreps(
+ irreps_in=irreps_in,
+ required_irreps_in=[
+ self.field,
+ self.edge_invariant_field,
+ self.node_invariant_field,
+ ],
+ )
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor([avg_num_neighbors] * num_layers).rsqrt(),
+ )
+
+ latent = functools.partial(latent, **latent_kwargs)
+ env_embed = functools.partial(env_embed, **env_embed_kwargs)
+
+ self.latents = torch.nn.ModuleList([])
+ self.env_embed_mlps = torch.nn.ModuleList([])
+ self.tps = torch.nn.ModuleList([])
+ self.linears = torch.nn.ModuleList([])
+ self.env_linears = torch.nn.ModuleList([])
+
+ # Embed to the spharm * it as mul
+ input_irreps = self.irreps_in[self.field]
+ # this is not inherant, but no reason to fix right now:
+ assert all(mul == 1 for mul, ir in input_irreps)
+ env_embed_irreps = o3.Irreps([(1, ir) for _, ir in input_irreps])
+ assert (
+ env_embed_irreps[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+ self._input_pad = (
+ int(math.ceil(env_embed_irreps.dim / pad_to_alignment)) * pad_to_alignment
+ ) - env_embed_irreps.dim
+ self.register_buffer("_zero", torch.zeros(1, 1))
+
+ # Initially, we have the B(r)Y(\vec{r})-projection of the edges
+ # (possibly embedded)
+ if self.embed_initial_edge:
+ arg_irreps = env_embed_irreps
+ else:
+ arg_irreps = input_irreps
+
+ # - begin irreps -
+ # start to build up the irreps for the iterated TPs
+ tps_irreps = [arg_irreps]
+
+ for layer_idx in range(num_layers):
+ # Create higher order terms cause there are more TPs coming
+ if layer_idx == 0:
+ # Add parity irreps
+ ir_out = []
+ for (mul, ir) in env_embed_irreps:
+ if self.nonscalars_include_parity: # make all irreps except 0e have o and e
+ # add both parity options
+ ir_out.append((1, (ir.l, 1)))
+ ir_out.append((1, (ir.l, -1)))
+ else:
+ # add only the parity option seen in the inputs
+ ir_out.append((1, ir))
+
+ ir_out = o3.Irreps(ir_out)
+
+ if layer_idx == self.num_layers - 1:
+ # ^ means we're doing the last layer
+ # No more TPs follow this, so only need scalars
+ ir_out = o3.Irreps([(1, (0, 1))])
+
+ # Prune impossible paths
+ ir_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in ir_out
+ if tp_path_exists(arg_irreps, env_embed_irreps, ir)
+ ]
+ )
+
+ # the argument to the next tensor product is the output of this one
+ arg_irreps = ir_out
+ tps_irreps.append(ir_out)
+ # - end build irreps -
+
+ # == Remove unneeded paths ==
+ out_irreps = tps_irreps[-1]
+ new_tps_irreps = [out_irreps]
+ for arg_irreps in reversed(tps_irreps[:-1]):
+ new_arg_irreps = []
+ for mul, arg_ir in arg_irreps:
+ for _, env_ir in env_embed_irreps:
+ if any(i in out_irreps for i in arg_ir * env_ir):
+ # arg_ir is useful: arg_ir * env_ir has a path to something we want
+ new_arg_irreps.append((mul, arg_ir))
+ # once its useful once, we keep it no matter what
+ break
+ new_arg_irreps = o3.Irreps(new_arg_irreps)
+ new_tps_irreps.append(new_arg_irreps)
+ out_irreps = new_arg_irreps
+
+ assert len(new_tps_irreps) == len(tps_irreps)
+ tps_irreps = list(reversed(new_tps_irreps))
+ del new_tps_irreps
+
+ assert tps_irreps[-1].lmax == 0
+
+ tps_irreps_in = tps_irreps[:-1]
+ tps_irreps_out = tps_irreps[1:]
+ del tps_irreps
+
+ # Environment builder:
+ self._env_weighter = MakeWeightedChannels(
+ irreps_in=input_irreps,
+ multiplicity_out=env_embed_multiplicity,
+ pad_to_alignment=pad_to_alignment,
+ )
+
+ self._n_scalar_outs = []
+
+ # == Build TPs ==
+ for layer_idx, (arg_irreps, out_irreps) in enumerate(
+ zip(tps_irreps_in, tps_irreps_out)
+ ):
+ # Make the env embed linear
+ if self.linear_after_env_embed:
+ self.env_linears.append(
+ Linear(
+ [(env_embed_multiplicity, ir) for _, ir in env_embed_irreps],
+ [(env_embed_multiplicity, ir) for _, ir in env_embed_irreps],
+ shared_weights=True,
+ internal_weights=True,
+ )
+ )
+ else:
+ self.env_linears.append(torch.nn.Identity())
+ # Make TP
+ tmp_i_out: int = 0
+ instr = []
+ n_scalar_outs: int = 0
+ full_out_irreps = []
+ for i_out, (_, ir_out) in enumerate(out_irreps):
+ for i_1, (_, ir_1) in enumerate(arg_irreps):
+ for i_2, (_, ir_2) in enumerate(env_embed_irreps):
+ if ir_out in ir_1 * ir_2:
+ if ir_out == SCALAR:
+ n_scalar_outs += 1
+ instr.append((i_1, i_2, tmp_i_out))
+ full_out_irreps.append((env_embed_multiplicity, ir_out))
+ tmp_i_out += 1
+ full_out_irreps = o3.Irreps(full_out_irreps)
+ self._n_scalar_outs.append(n_scalar_outs)
+ assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ tp = Contracter(
+ irreps_in1=o3.Irreps(
+ [
+ (
+ (
+ env_embed_multiplicity
+ if layer_idx > 0 or self.embed_initial_edge
+ else 1
+ ),
+ ir,
+ )
+ for _, ir in arg_irreps
+ ]
+ ),
+ irreps_in2=o3.Irreps(
+ [(env_embed_multiplicity, ir) for _, ir in env_embed_irreps]
+ ),
+ irreps_out=o3.Irreps(
+ [(env_embed_multiplicity, ir) for _, ir in full_out_irreps]
+ ),
+ instructions=instr,
+ # For the first layer, we have the unprocessed edges
+ # coming in from the input if `not self.embed_initial_edge`.
+ # These don't match the embedding in mul, so we have
+ # to use uvv --- since the input edges should be mul
+ # of one in normal circumstances, this is still plenty fast.
+ # For this reason it also doesn't increase the number of weights.
+ connection_mode=(
+ "uuu" if layer_idx > 0 or self.embed_initial_edge else "uvv"
+ ),
+ shared_weights=False,
+ has_weight=False,
+ pad_to_alignment=pad_to_alignment,
+ sparse_mode=sparse_mode,
+ )
+ self.tps.append(tp)
+ # we extract the scalars from the first irrep of the tp
+ assert out_irreps[0].ir == SCALAR
+
+ # Make env embed mlp
+ generate_n_weights = (
+ self._env_weighter.weight_numel
+ ) # the weight for the edge embedding
+ if layer_idx == 0 and self.embed_initial_edge:
+ # also need weights to embed the edge itself
+ # this is because the 2 body latent is mixed in with the first layer
+ # in terms of code
+ generate_n_weights += self._env_weighter.weight_numel
+
+ # the linear acts after the extractor
+ # this linear act on the reduced V and gives a out_irreps that is just reduced
+ self.linears.append(
+ Linear(
+ full_out_irreps,
+ [(env_embed_multiplicity, ir) for _, ir in out_irreps],
+ shared_weights=True,
+ internal_weights=True,
+ pad_to_alignment=pad_to_alignment,
+ )
+ )
+
+ if layer_idx == 0:
+ # at the first layer, we have no invariants from previous TPs
+ self.latents.append(
+ two_body_latent(
+ mlp_input_dimension=(
+ (
+ # Node invariants for center and neighbor (chemistry)
+ 2 * self.irreps_in[self.node_invariant_field].num_irreps
+ # Plus edge invariants for the edge (radius).
+ + self.irreps_in[self.edge_invariant_field].num_irreps
+ )
+ ),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+ )
+
+ else:
+ self.latents.append(
+ latent(
+ mlp_input_dimension=(
+ (
+ # the embedded latent invariants from the previous layer(s)
+ self.latents[-1].out_features
+ # and the invariants extracted from the last layer's TP:
+ + env_embed_multiplicity * n_scalar_outs
+ )
+ ),
+ mlp_output_dimension=None,
+ )
+ )
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps.append(
+ env_embed(
+ mlp_input_dimension=self.latents[-1].out_features,
+ mlp_output_dimension=generate_n_weights,
+ )
+ )
+
+ # For the final layer, we specialize:
+ # we don't need to propagate nonscalars, so there is no TP
+ # thus we only need the latent:
+ self.final_latent = latent(
+ mlp_input_dimension=self.latents[-1].out_features
+ + env_embed_multiplicity * n_scalar_outs,
+ mlp_output_dimension=None,
+ )
+ # - end build modules -
+
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(self.num_layers)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios.min() > 0.0
+ assert latent_resnet_update_ratios.min() < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+ assert latent_resnet_update_params.shape == (
+ num_layers,
+ ), f"There must be {num_layers} layer resnet update ratios (layer0:layer1, layer1:layer2)"
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ # - Per-layer cutoffs -
+ if per_layer_cutoffs is None:
+ per_layer_cutoffs = torch.full((num_layers + 1,), r_max)
+ self.register_buffer("per_layer_cutoffs", torch.as_tensor(per_layer_cutoffs))
+ assert torch.all(self.per_layer_cutoffs <= r_max)
+ assert self.per_layer_cutoffs.shape == (
+ num_layers + 1,
+ ), "Must be one per-layer cutoff for layer 0 and every layer for a total of {num_layers} cutoffs (the first applies to the two body latent, which is 'layer 0')"
+ assert (
+ self.per_layer_cutoffs[1:] <= self.per_layer_cutoffs[:-1]
+ ).all(), "Per-layer cutoffs must be equal or decreasing"
+ assert (
+ self.per_layer_cutoffs.min() > 0
+ ), "Per-layer cutoffs must be >0. To remove higher layers entirely, lower `num_layers`."
+ self._latent_dim = self.final_latent.out_features
+ self.register_buffer("_zero", torch.as_tensor(0.0))
+
+ self.irreps_out.update(
+ {
+ self.latent_out_field: o3.Irreps(
+ [(self.final_latent.out_features, (0, 1))]
+ ),
+ }
+ )
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ """Evaluate.
+
+ :param data: AtomicDataDict.Type
+ :return: AtomicDataDict.Type
+ """
+ edge_center = data[AtomicDataDict.EDGE_INDEX_KEY][0]
+ edge_neighbor = data[AtomicDataDict.EDGE_INDEX_KEY][1]
+
+ edge_attr = data[self.field]
+ # pad edge_attr
+ if self._input_pad > 0:
+ edge_attr = torch.cat(
+ (
+ edge_attr,
+ self._zero.expand(len(edge_attr), self._input_pad),
+ ),
+ dim=-1,
+ )
+
+ edge_length = data[AtomicDataDict.EDGE_LENGTH_KEY]
+ num_edges: int = len(edge_attr)
+ edge_invariants = data[self.edge_invariant_field]
+ node_invariants = data[self.node_invariant_field]
+ # pre-declare variables as Tensors for TorchScript
+ scalars = self._zero
+ coefficient_old = scalars
+ coefficient_new = scalars
+ # Initialize state
+ latents = torch.zeros(
+ (num_edges, self._latent_dim),
+ dtype=edge_attr.dtype,
+ device=edge_attr.device,
+ )
+ active_edges = torch.arange(
+ num_edges,
+ device=edge_attr.device,
+ )
+
+ # For the first layer, we use the input invariants:
+ # The center and neighbor invariants and edge invariants
+ latent_inputs_to_cat = [
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ]
+ # The nonscalar features. Initially, the edge data.
+ features = edge_attr
+
+ layer_index: int = 0
+ # compute the sigmoids vectorized instead of each loop
+ layer_update_coefficients = self._latent_resnet_update_params.sigmoid()
+
+ # Vectorized precompute per layer cutoffs
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs_all = cosine_cutoff(
+ edge_length,
+ self.per_layer_cutoffs,
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ )
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs_all = polynomial_cutoff(
+ edge_length, self.per_layer_cutoffs, p=self.polynomial_cutoff_p
+ )
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ # !!!! REMEMBER !!!! update final layer if update the code in main loop!!!
+ # This goes through layer0, layer1, ..., layer_max-1
+ for latent, env_embed_mlp, env_linear, tp, linear in zip(
+ self.latents, self.env_embed_mlps, self.env_linears, self.tps, self.linears
+ ):
+ # Determine which edges are still in play
+ cutoff_coeffs = cutoff_coeffs_all[layer_index]
+ prev_mask = cutoff_coeffs[active_edges] > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ new_latents = latent(torch.cat(latent_inputs_to_cat, dim=-1)[prev_mask])
+ # Apply cutoff, which propagates through to everything else
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+
+ if self.latent_resnet and layer_index > 0:
+ this_layer_update_coeff = layer_update_coefficients[layer_index - 1]
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+ coefficient_old = torch.rsqrt(this_layer_update_coeff.square() + 1)
+ coefficient_new = this_layer_update_coeff * coefficient_old
+ # Residual update
+ # Note that it only runs when there are latents to resnet with, so not at the first layer
+ # index_add adds only to the edges for which we have something to contribute
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+ else:
+ # Normal (non-residual) update
+ # index_copy replaces, unlike index_add
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ # From the latents, compute the weights for active edges:
+ weights = env_embed_mlp(latents[active_edges])
+ w_index: int = 0
+
+ if self.embed_initial_edge and layer_index == 0:
+ # embed initial edge
+ env_w = weights.narrow(-1, w_index, self._env_weighter.weight_numel)
+ w_index += self._env_weighter.weight_numel
+ features = self._env_weighter(
+ features[prev_mask], env_w
+ ) # features is edge_attr
+ else:
+ # just take the previous features that we still need
+ features = features[prev_mask]
+
+ # Extract weights for the environment builder
+ env_w = weights.narrow(-1, w_index, self._env_weighter.weight_numel)
+ w_index += self._env_weighter.weight_numel
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_attr[active_edges], env_w),
+ edge_center[active_edges],
+ dim=0,
+ )
+ if self.env_sum_normalizations.ndim < 2:
+ # it's a scalar per layer
+ norm_const = self.env_sum_normalizations[layer_index]
+ else:
+ # it's per type
+ # get shape [N_atom, 1] for broadcasting
+ norm_const = self.env_sum_normalizations[
+ layer_index, data[AtomicDataDict.ATOM_TYPE_KEY]
+ ].unsqueeze(-1)
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = env_linear(local_env_per_edge)
+ # Copy to get per-edge
+ # Large allocation, but no better way to do this:
+ local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ features = tp(features, local_env_per_edge)
+
+ # Get invariants
+ # features has shape [z][mul][k]
+ # we know scalars are first
+ scalars = features[:, :, : self._n_scalar_outs[layer_index]].reshape(
+ features.shape[0], -1
+ )
+
+ # do the linear
+ features = linear(features)
+
+ # For layer2+, use the previous latents and scalars
+ # This makes it deep
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ # increment counter
+ layer_index += 1
+
+ # - final layer -
+ # due to TorchScript limitations, we have to
+ # copy and repeat the code here --- no way to
+ # escape the final iteration of the loop early
+ cutoff_coeffs = cutoff_coeffs_all[layer_index]
+ prev_mask = cutoff_coeffs[active_edges] > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+ new_latents = self.final_latent(
+ torch.cat(latent_inputs_to_cat, dim=-1)[prev_mask]
+ )
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ if self.latent_resnet:
+ this_layer_update_coeff = layer_update_coefficients[layer_index - 1]
+ coefficient_old = torch.rsqrt(this_layer_update_coeff.square() + 1)
+ coefficient_new = this_layer_update_coeff * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+ # - end final layer -
+
+ # final latents
+ data[self.latent_out_field] = latents
+
+ return data
\ No newline at end of file
diff --git a/dptb/nn/embedding/baseline.py b/dptb/nn/embedding/baseline.py
new file mode 100644
index 00000000..703c419f
--- /dev/null
+++ b/dptb/nn/embedding/baseline.py
@@ -0,0 +1,316 @@
+from torch_geometric.nn import MessagePassing
+from torch_geometric.nn import Aggregation
+import torch
+from typing import Optional, Tuple, Union
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..base import ResNet, FFN
+from torch.nn import Linear
+from dptb.utils.constants import dtype_dict
+from ..type_encode.one_hot import OneHotAtomEncoding
+from ..cutoff import polynomial_cutoff
+from ..radial_basis import BesselBasis
+from torch_runstats.scatter import scatter
+
+def get_neuron_config(nl):
+ n = len(nl)
+ if n % 2 == 0:
+ d_out = nl[-1]
+ nl = nl[:-1]
+ config = []
+ for i in range(1,len(nl)-1, 2):
+ config.append({'in_features': nl[i-1], 'hidden_features': nl[i], 'out_features': nl[i+1]})
+
+ if n % 2 == 0:
+ config.append({'in_features': nl[-1], 'out_features': d_out})
+
+ return config
+
+@Embedding.register("baseline")
+class BASELINE(torch.nn.Module):
+ def __init__(
+ self,
+ rc:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_axis: Union[int, torch.LongTensor, None]=None,
+ n_basis: Union[int, torch.LongTensor, None]=None,
+ n_radial: Union[int, torch.LongTensor, None]=None,
+ n_sqrt_radial: Union[int, torch.LongTensor, None]=None,
+ n_atom: int=1,
+ n_layer: int=1,
+ radial_net: dict={},
+ hidden_net: dict={},
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,):
+
+ super(BASELINE, self).__init__()
+
+ assert n_axis <= n_sqrt_radial
+ self.n_radial = n_radial
+ self.n_sqrt_radial = n_sqrt_radial
+ self.n_axis = n_axis
+
+ if isinstance(rc, float):
+ self.rc = torch.tensor(rc, dtype=dtype, device=device)
+ else:
+ self.rc = rc
+
+ self.p = p
+ self.node_emb_layer = _NODE_EMB(rc=self.rc, p=p, n_axis=n_axis, n_basis=n_basis, n_radial=n_radial, n_sqrt_radial=n_sqrt_radial, n_atom=n_atom, radial_net=radial_net, dtype=dtype, device=device)
+ self.layers = torch.nn.ModuleList([])
+ for _ in range(n_layer):
+ self.layers.append(BaselineLayer(n_atom=n_atom, rc=self.rc, p=p, n_radial=n_radial, n_sqrt_radial=n_sqrt_radial, n_axis=n_axis, n_hidden=n_axis*n_sqrt_radial, hidden_net=hidden_net, radial_net=radial_net, dtype=dtype, device=device))
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = self.onehot(data)
+ data = AtomicDataDict.with_env_vectors(data, with_lengths=True)
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ env_radial, edge_radial, node_emb, env_hidden, edge_hidden = self.node_emb_layer(
+ env_vectors=data[AtomicDataDict.ENV_VECTORS_KEY],
+ atom_attr=data[AtomicDataDict.NODE_ATTRS_KEY],
+ env_index=data[AtomicDataDict.ENV_INDEX_KEY],
+ edge_index=data[AtomicDataDict.EDGE_INDEX_KEY],
+ env_length=data[AtomicDataDict.ENV_LENGTH_KEY],
+ edge_length=data[AtomicDataDict.EDGE_LENGTH_KEY],
+ )
+
+
+ for layer in self.layers:
+ env_radial, env_hidden, edge_radial, edge_hidden, node_emb = layer(
+ env_length=data[AtomicDataDict.ENV_LENGTH_KEY],
+ edge_length=data[AtomicDataDict.EDGE_LENGTH_KEY],
+ env_index=data[AtomicDataDict.ENV_INDEX_KEY],
+ edge_index=data[AtomicDataDict.EDGE_INDEX_KEY],
+ env_radial=env_radial,
+ edge_radial=edge_radial,
+ node_emb=node_emb,
+ env_hidden=env_hidden,
+ edge_hidden=edge_hidden,
+ )
+
+ # env_length = data[AtomicDataDict.ENV_LENGTH_KEY]
+ # data[AtomicDataDict.NODE_FEATURES_KEY] = \
+ # scatter(src=polynomial_cutoff(x=env_length, r_max=self.rc, p=self.p).reshape(-1, 1) * env_radial, index=data[AtomicDataDict.ENV_INDEX_KEY][0], dim=0, reduce="sum")
+ data[AtomicDataDict.NODE_FEATURES_KEY] = node_emb
+
+ data[AtomicDataDict.EDGE_FEATURES_KEY] = edge_radial
+
+ return data
+
+ @property
+ def out_edge_dim(self):
+ return self.n_radial
+
+ @property
+ def out_node_dim(self):
+ return self.n_sqrt_radial * self.n_axis
+
+class SE2Aggregation(Aggregation):
+ def forward(self, x: torch.Tensor, index: torch.LongTensor, **kwargs):
+ """_summary_
+
+ Parameters
+ ----------
+ x : tensor of size (N, d), where d dimension looks like (emb(s(r)), \hat{x}, \hat{y}, \hat{z})
+ The is the embedding of the env_vectors
+ index : _type_
+ _description_
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+ direct_vec = x[:, -3:]
+ x = x[:,:-3].unsqueeze(-1) * direct_vec.unsqueeze(1) # [N_env, D, 3]
+ return self.reduce(x, index, reduce="mean", dim=0) # [N_atom, D, 3] following the orders of atom index.
+
+
+class _NODE_EMB(MessagePassing):
+ def __init__(
+ self,
+ rc:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_axis: Union[int, torch.LongTensor, None]=None,
+ n_basis: Union[int, torch.LongTensor, None]=None,
+ n_sqrt_radial: Union[int, torch.LongTensor, None]=None,
+ n_radial: Union[int, torch.LongTensor, None]=None,
+ aggr: SE2Aggregation=SE2Aggregation(),
+ radial_net: dict={},
+ n_atom: int=1,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"), **kwargs):
+
+ super(_NODE_EMB, self).__init__(aggr=aggr, **kwargs)
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ if n_axis == None:
+ self.n_axis = n_sqrt_radial
+ else:
+ self.n_axis = n_axis
+
+ radial_net["config"] = get_neuron_config([2*n_atom+n_basis]+radial_net["neurons"]+[n_radial])
+ self.mlp_radial = FFN(**radial_net, device=device, dtype=dtype)
+ radial_net["config"] = get_neuron_config([2*n_atom+n_basis]+radial_net["neurons"]+[n_sqrt_radial])
+ self.mlp_sqrt_radial = FFN(**radial_net, device=device, dtype=dtype)
+ self.mlp_emb = Linear(n_radial, self.n_axis*n_sqrt_radial, device=device, dtype=dtype)
+ if isinstance(rc, float):
+ self.rc = torch.tensor(rc, dtype=dtype, device=device)
+ else:
+ self.rc = rc
+
+ self.p = p
+
+ self.n_axis = n_axis
+ self.device = device
+ self.dtype = dtype
+
+ self.n_out = self.n_axis * n_sqrt_radial
+
+ self.bessel = BesselBasis(r_max=rc, num_basis=n_basis, trainable=True)
+ self.node_layer_norm = torch.nn.LayerNorm(self.n_out, elementwise_affine=True)
+ self.edge_layer_norm = torch.nn.LayerNorm(n_radial, elementwise_affine=True)
+
+ def forward(self, env_vectors, atom_attr, env_index, edge_index, env_length, edge_length):
+ n_env = env_index.shape[1]
+ n_edge = edge_index.shape[1]
+ env_attr = atom_attr[env_index].transpose(1,0).reshape(n_env,-1)
+ edge_attr = atom_attr[edge_index].transpose(1,0).reshape(n_edge,-1)
+ ud_env = polynomial_cutoff(x=env_length, r_max=self.rc, p=self.p).reshape(-1, 1)
+ ud_edge = polynomial_cutoff(x=edge_length, r_max=self.rc, p=self.p).reshape(-1, 1)
+
+ env_sqrt_radial = self.mlp_sqrt_radial(torch.cat([env_attr, ud_env * self.bessel(env_length)], dim=-1)) * ud_env
+
+ env_radial = self.edge_layer_norm(self.mlp_radial(torch.cat([env_attr, ud_env * self.bessel(env_length)], dim=-1))) * ud_env
+ edge_radial = self.edge_layer_norm(self.mlp_radial(torch.cat([edge_attr, ud_edge * self.bessel(edge_length)], dim=-1))) * ud_edge
+
+ node_emb = self.propagate(env_index, env_vectors=env_vectors, env_length=env_length, ud=ud_env, env_sqrt_radial=env_sqrt_radial) # [N_atom, D, 3]
+ env_hidden = self.mlp_emb(env_radial) * (node_emb[env_index[1]]+node_emb[env_index[0]]) * 0.5
+ edge_hidden = self.mlp_emb(edge_radial) * (node_emb[edge_index[1]]+node_emb[edge_index[0]]) * 0.5
+
+ return env_radial, edge_radial, node_emb, env_hidden, edge_hidden
+
+ def message(self, env_vectors, env_length, env_sqrt_radial, ud):
+ snorm = env_length.unsqueeze(-1) * ud
+ env_vectors = snorm * env_vectors / env_length.unsqueeze(-1)
+ return torch.cat([env_sqrt_radial, env_vectors], dim=-1) # [N_env, D_emb + 3]
+
+ def update(self, aggr_out):
+ """_summary_
+
+ Parameters
+ ----------
+ aggr_out : The output of the aggregation layer, which is the mean of the message vectors as size [N, D, 3]
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+ out = torch.bmm(aggr_out, aggr_out.transpose(1, 2))[:,:,:self.n_axis].flatten(start_dim=1, end_dim=2)
+
+
+ return self.node_layer_norm(out) # [N, D*D]
+
+
+class BaselineLayer(MessagePassing):
+ def __init__(
+ self,
+ rc:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_radial: int,
+ n_sqrt_radial: int,
+ n_axis: int,
+ n_atom: int,
+ n_hidden: int,
+ radial_net: dict={},
+ hidden_net: dict={},
+ aggr="mean",
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"), **kwargs):
+
+ super(BaselineLayer, self).__init__(aggr=aggr, **kwargs)
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ if isinstance(rc, float):
+ self.rc = torch.tensor(rc, dtype=dtype, device=device)
+ else:
+ self.rc = rc
+
+ self.p = p
+
+ self.mlp_emb = Linear(n_radial, n_axis*n_sqrt_radial, device=device, dtype=dtype)
+ hidden_net["config"] = get_neuron_config([n_axis*n_sqrt_radial+n_hidden]+hidden_net["neurons"]+[n_hidden])
+ self.mlp_hid = FFN(**hidden_net, device=device, dtype=dtype)
+ radial_net["config"] = get_neuron_config([n_radial+n_hidden]+radial_net["neurons"]+[n_radial])
+ self.mlp_radial = ResNet(**radial_net, dtype=dtype, device=device)
+
+ self.node_layer_norm = torch.nn.LayerNorm(n_axis*n_sqrt_radial, elementwise_affine=True)
+ self.edge_layer_norm = torch.nn.LayerNorm(n_radial, elementwise_affine=True)
+
+ self.device = device
+ self.dtype = dtype
+
+ def forward(self, env_length, edge_length, edge_index, env_index, env_radial, edge_radial, node_emb, env_hidden, edge_hidden):
+ # n_env = env_index.shape[1]
+ # n_edge = edge_index.shape[1]
+ # env_attr = atom_attr[env_index].transpose(1,0).reshape(n_env,-1)
+ # edge_attr = atom_attr[edge_index].transpose(1,0).reshape(n_edge,-1)
+
+ env_weight = self.mlp_emb(env_radial)
+ # node_emb can descripe the node very well
+ node_emb = 0.89442719 * node_emb + 0.4472 * self.propagate(env_index, node_emb=node_emb[env_index[1]], env_weight=env_weight) # [N_atom, D, 3]
+ # import matplotlib.pyplot as plt
+ # fig = plt.figure(figsize=(15,4))
+ # plt.plot(node_emb.detach().T)
+ # plt.title("node_emb")
+ # plt.show()
+
+ # env_hidden 长得太像了
+ env_hidden = self.mlp_hid(torch.cat([node_emb[env_index[0]], env_hidden], dim=-1))
+ edge_hidden = self.mlp_hid(torch.cat([node_emb[edge_index[0]], edge_hidden], dim=-1))
+ # node_emb = _node_emb + node_emb
+
+ # import matplotlib.pyplot as plt
+ # fig = plt.figure(figsize=(15,4))
+ # plt.plot(edge_hidden.detach().T)
+ # plt.title("edge_hidden")
+ # plt.show()
+
+ ud_env = polynomial_cutoff(x=env_length, r_max=self.rc, p=self.p).reshape(-1, 1)
+ ud_edge = polynomial_cutoff(x=edge_length, r_max=self.rc, p=self.p).reshape(-1, 1)
+ env_radial = 0.89442719 * env_radial + 0.4472 * ud_env * self.edge_layer_norm(self.mlp_radial(torch.cat([env_radial, env_hidden], dim=-1)))
+ edge_radial = 0.89442719 * edge_radial + 0.4472 * ud_edge * self.edge_layer_norm(self.mlp_radial(torch.cat([edge_radial, edge_hidden], dim=-1)))
+
+ return env_radial, env_hidden, edge_radial, edge_hidden, node_emb
+
+ def message(self, node_emb, env_weight):
+
+ return env_weight * node_emb
+
+ def update(self, aggr_out):
+ """_summary_
+
+ Parameters
+ ----------
+ aggr_out : The output of the aggregation layer, which is the mean of the message vectors as size [N, D, 3]
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+
+ aggr_out = aggr_out.reshape(aggr_out.shape[0], -1)
+ return self.node_layer_norm(aggr_out) # [N, D*D]
\ No newline at end of file
diff --git a/dptb/nn/embedding/deephe3.py b/dptb/nn/embedding/deephe3.py
new file mode 100644
index 00000000..912f41e5
--- /dev/null
+++ b/dptb/nn/embedding/deephe3.py
@@ -0,0 +1,99 @@
+from .from_deephe3.deephe3 import Net
+import torch
+import torch.nn as nn
+import e3nn.o3 as o3
+from dptb.data.transforms import OrbitalMapper
+from dptb.data import AtomicData, AtomicDataDict
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+from dptb.nn.embedding.emb import Embedding
+from typing import Dict, Union, List, Tuple, Optional, Any
+
+
+@Embedding.register("deeph-e3")
+class E3DeePH(nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ n_atom: int=1,
+ irreps_embed: o3.Irreps=o3.Irreps("64e"),
+ lmax: int=3,
+ irreps_mid: o3.Irreps=o3.Irreps("64x0e+32x1o+16x2e+8x3o+8x4e+4x5o"),
+ n_layer: int=3,
+ rc: float=5.0,
+ n_basis: int=128,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+
+ super(E3DeePH, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+
+ irreps_mid = o3.Irreps(irreps_mid)
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+
+ self.idp.get_irreps(no_parity=False)
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ # if not no_parity:
+ # irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ # else:
+ # irreps_sh=o3.Irreps([(1, (i, 1)) for i in range(lmax + 1)])
+
+ self.net = Net(
+ num_species=n_atom,
+ irreps_embed_node=irreps_embed,
+ irreps_sh=irreps_sh,
+ irreps_mid_node=irreps_mid,
+ irreps_post_node=self.idp.orbpair_irreps.sort()[0].simplify(), # it can be derived from the basis
+ irreps_out_node=self.idp.orbpair_irreps, # it can be dervied from the basis
+ irreps_edge_init=irreps_embed,
+ irreps_mid_edge=irreps_mid,
+ irreps_post_edge=self.idp.orbpair_irreps.sort()[0].simplify(), # it can be dervied from the basis
+ irreps_out_edge=self.idp.orbpair_irreps, # it can be dervied from the basis
+ num_block=n_layer,
+ r_max=rc,
+ use_sc=False,
+ no_parity=False,
+ use_sbf=False,
+ selftp=False,
+ edge_upd=True,
+ only_ij=False,
+ num_basis=n_basis
+ )
+
+
+ self.net.to(self.device)
+
+ self.out_irreps = self.idp.orbpair_irreps
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ data = with_batch(data)
+
+ node_feature, edge_feature = self.net(data)
+ data[AtomicDataDict.NODE_FEATURES_KEY] = node_feature
+ data[AtomicDataDict.EDGE_FEATURES_KEY] = edge_feature
+
+ return data
+
+ @property
+ def out_edge_irreps(self):
+ return self.out_irreps
+
+ @property
+ def out_node_irreps(self):
+ return self.out_irreps
diff --git a/dptb/nn/embedding/e3baseline.py b/dptb/nn/embedding/e3baseline.py
new file mode 100644
index 00000000..8617bf7e
--- /dev/null
+++ b/dptb/nn/embedding/e3baseline.py
@@ -0,0 +1,926 @@
+from typing import Optional, List, Union, Dict
+import math
+import functools
+import warnings
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from e3nn import o3
+from e3nn.nn import Gate, Activation
+from e3nn.nn._batchnorm import BatchNorm
+from e3nn.o3 import TensorProduct, Linear, SphericalHarmonics, FullyConnectedTensorProduct
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..radial_basis import BesselBasis
+from dptb.nn.graph_mixin import GraphModuleMixin
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+import math
+from dptb.data.transforms import OrbitalMapper
+from ..type_encode.one_hot import OneHotAtomEncoding
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+
+from math import ceil
+
+@Embedding.register("e3baseline")
+class E3BaseLineModel(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ # required params
+ n_atom: int=1,
+ n_layers: int=3,
+ n_radial_basis: int=10,
+ r_max: float=5.0,
+ lmax: int=4,
+ irreps_hidden: o3.Irreps=None,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ sh_normalized: bool = True,
+ sh_normalization: str = "component",
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [256, 256, 512],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+
+ super(E3BaseLineModel, self).__init__()
+
+ irreps_hidden = o3.Irreps(irreps_hidden)
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_irreps(no_parity=False)
+
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ orbpair_irreps = self.idp.orbpair_irreps.sort()[0].simplify()
+
+ # check if the irreps setting satisfied the requirement of idp
+ irreps_out = []
+ for mul, ir1 in irreps_hidden:
+ for _, ir2 in orbpair_irreps:
+ irreps_out += [o3.Irrep(str(irr)) for irr in ir1*ir2]
+ irreps_out = o3.Irreps(irreps_out).sort()[0].simplify()
+
+ assert all(ir in irreps_out for _, ir in orbpair_irreps), "hidden irreps should at least cover all the reqired irreps in the hamiltonian data {}".format(pair_irreps)
+
+ self.sh = SphericalHarmonics(
+ irreps_sh, sh_normalized, sh_normalization
+ )
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ self.init_layer = InitLayer(
+ idp=self.idp,
+ num_types=n_atom,
+ n_radial_basis=n_radial_basis,
+ r_max=r_max,
+ irreps_sh=irreps_sh,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ two_body_latent_kwargs=latent_kwargs,
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio=r_start_cos_ratio,
+ PolynomialCutoff_p=PolynomialCutoff_p,
+ cutoff_type=cutoff_type,
+ device=device,
+ dtype=dtype,
+ )
+
+ self.layers = torch.nn.ModuleList()
+ latent_in =latent_kwargs["mlp_latent_dimensions"][-1]
+ # actually, we can derive the least required irreps_in and out from the idp's node and pair irreps
+ for i in range(n_layers):
+ if i == 0:
+ irreps_in = self.init_layer.irreps_out
+ else:
+ irreps_in = irreps_hidden
+
+ if i == n_layers - 1:
+ irreps_out = orbpair_irreps.sort()[0].simplify()
+ else:
+ irreps_out = irreps_hidden
+
+ self.layers.append(Layer(
+ num_types=n_atom,
+ avg_num_neighbors=avg_num_neighbors,
+ irreps_sh=irreps_sh,
+ irreps_in=irreps_in,
+ irreps_out=irreps_out,
+ # general hyperparameters:
+ linear_after_env_embed=linear_after_env_embed,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ latent_kwargs=latent_kwargs,
+ latent_in=latent_in,
+ latent_resnet=latent_resnet,
+ latent_resnet_update_ratios=latent_resnet_update_ratios,
+ latent_resnet_update_ratios_learnable=latent_resnet_update_ratios_learnable,
+ )
+ )
+
+ # initilize output_layer
+ self.out_edge = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ # data = with_env_vectors(data, with_lengths=True)
+ data = with_batch(data)
+
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_sh = self.sh(data[_keys.EDGE_VECTORS_KEY][:,[1,2,0]])
+ edge_length = data[_keys.EDGE_LENGTH_KEY]
+
+
+ data = self.onehot(data)
+ node_one_hot = data[_keys.NODE_ATTRS_KEY]
+ atom_type = data[_keys.ATOM_TYPE_KEY].flatten()
+ bond_type = data[_keys.EDGE_TYPE_KEY].flatten()
+ latents, features, cutoff_coeffs, active_edges = self.init_layer(edge_index, bond_type, edge_sh, edge_length, node_one_hot)
+
+ for layer in self.layers:
+ latents, features, cutoff_coeffs, active_edges = layer(edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges)
+
+
+ if self.layers[-1].env_sum_normalizations.ndim < 1:
+ norm_const = self.layers[-1].env_sum_normalizations
+ else:
+ norm_const = self.layers[-1].env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ data[_keys.EDGE_FEATURES_KEY] = torch.zeros(edge_index.shape[1], self.idp.orbpair_irreps.dim, dtype=self.dtype, device=self.device)
+ data[_keys.EDGE_FEATURES_KEY] = torch.index_copy(data[_keys.EDGE_FEATURES_KEY], 0, active_edges, self.out_edge(features))
+ node_features = scatter(features, edge_index[0][active_edges], dim=0)
+ data[_keys.NODE_FEATURES_KEY] = self.out_node(node_features * norm_const)
+
+ return data
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = o3.Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+@compile_mode("script")
+class MakeWeightedChannels(torch.nn.Module):
+ weight_numel: int
+ multiplicity_out: Union[int, list]
+ _num_irreps: int
+
+ def __init__(
+ self,
+ irreps_in,
+ multiplicity_out: Union[int, list],
+ pad_to_alignment: int = 1,
+ ):
+ super().__init__()
+ assert all(mul == 1 for mul, _ in irreps_in)
+ assert multiplicity_out >= 1
+ # Each edgewise output multiplicity is a per-irrep weighted sum over the input
+ # So we need to apply the weight for the ith irrep to all DOF in that irrep
+ w_index = []
+ idx = 0
+ self._num_irreps = 0
+ for (mul, ir) in irreps_in:
+ w_index += sum(([ix] * ir.dim for ix in range(idx, idx + mul)), [])
+ idx += mul
+ self._num_irreps += mul
+ # w_index = sum(([i] * ir.dim for i, (mul, ir) in enumerate(irreps_in)), [])
+ # pad to padded length
+ n_pad = (
+ int(ceil(irreps_in.dim / pad_to_alignment)) * pad_to_alignment
+ - irreps_in.dim
+ )
+ # use the last weight, what we use doesn't matter much
+ w_index += [w_index[-1]] * n_pad
+ self.register_buffer("_w_index", torch.as_tensor(w_index, dtype=torch.long))
+ # there is
+ self.multiplicity_out = multiplicity_out
+ self.weight_numel = self._num_irreps * multiplicity_out
+
+ def forward(self, edge_attr, weights):
+ # weights are [z, u, num_i]
+ # edge_attr are [z, i]
+ # i runs over all irreps, which is why the weights need
+ # to be indexed in order to go from [num_i] to [i]
+ return torch.einsum(
+ "zi,zui->zui",
+ edge_attr,
+ weights.view(
+ -1,
+ self.multiplicity_out,
+ self._num_irreps,
+ )[:, :, self._w_index],
+ )
+
+@torch.jit.script
+def ShiftedSoftPlus(x):
+ return torch.nn.functional.softplus(x) - math.log(2.0)
+
+class ScalarMLPFunction(CodeGenMixin, torch.nn.Module):
+ """Module implementing an MLP according to provided options."""
+
+ in_features: int
+ out_features: int
+
+ def __init__(
+ self,
+ mlp_input_dimension: Optional[int],
+ mlp_latent_dimensions: List[int],
+ mlp_output_dimension: Optional[int],
+ mlp_nonlinearity: Optional[str] = "silu",
+ mlp_initialization: str = "normal",
+ mlp_dropout_p: float = 0.0,
+ mlp_batchnorm: bool = False,
+ ):
+ super().__init__()
+ nonlinearity = {
+ None: None,
+ "silu": torch.nn.functional.silu,
+ "ssp": ShiftedSoftPlus,
+ }[mlp_nonlinearity]
+ if nonlinearity is not None:
+ nonlin_const = normalize2mom(nonlinearity).cst
+ else:
+ nonlin_const = 1.0
+
+ dimensions = (
+ ([mlp_input_dimension] if mlp_input_dimension is not None else [])
+ + mlp_latent_dimensions
+ + ([mlp_output_dimension] if mlp_output_dimension is not None else [])
+ )
+ assert len(dimensions) >= 2 # Must have input and output dim
+ num_layers = len(dimensions) - 1
+
+ self.in_features = dimensions[0]
+ self.out_features = dimensions[-1]
+
+ # Code
+ params = {}
+ graph = fx.Graph()
+ tracer = fx.proxy.GraphAppendingTracer(graph)
+
+ def Proxy(n):
+ return fx.Proxy(n, tracer=tracer)
+
+ features = Proxy(graph.placeholder("x"))
+ norm_from_last: float = 1.0
+
+ base = torch.nn.Module()
+
+ for layer, (h_in, h_out) in enumerate(zip(dimensions, dimensions[1:])):
+ # do dropout
+ if mlp_dropout_p > 0:
+ # only dropout if it will do something
+ # dropout before linear projection- https://stats.stackexchange.com/a/245137
+ features = Proxy(graph.call_module("_dropout", (features.node,)))
+
+ # make weights
+ w = torch.empty(h_in, h_out)
+
+ if mlp_initialization == "normal":
+ w.normal_()
+ elif mlp_initialization == "uniform":
+ # these values give < x^2 > = 1
+ w.uniform_(-math.sqrt(3), math.sqrt(3))
+ elif mlp_initialization == "orthogonal":
+ # this rescaling gives < x^2 > = 1
+ torch.nn.init.orthogonal_(w, gain=math.sqrt(max(w.shape)))
+ else:
+ raise NotImplementedError(
+ f"Invalid mlp_initialization {mlp_initialization}"
+ )
+
+ # generate code
+ params[f"_weight_{layer}"] = w
+ w = Proxy(graph.get_attr(f"_weight_{layer}"))
+ w = w * (
+ norm_from_last / math.sqrt(float(h_in))
+ ) # include any nonlinearity normalization from previous layers
+ features = torch.matmul(features, w)
+
+ if mlp_batchnorm:
+ # if we call batchnorm, do it after the nonlinearity
+ features = Proxy(graph.call_module(f"_bn_{layer}", (features.node,)))
+ setattr(base, f"_bn_{layer}", torch.nn.BatchNorm1d(h_out))
+
+ # generate nonlinearity code
+ if nonlinearity is not None and layer < num_layers - 1:
+ features = nonlinearity(features)
+ # add the normalization const in next layer
+ norm_from_last = nonlin_const
+
+ graph.output(features.node)
+
+ for pname, p in params.items():
+ setattr(base, pname, torch.nn.Parameter(p))
+
+ if mlp_dropout_p > 0:
+ # with normal dropout everything blows up
+ base._dropout = torch.nn.AlphaDropout(p=mlp_dropout_p)
+
+ self._codegen_register({"_forward": fx.GraphModule(base, graph)})
+
+ def forward(self, x):
+ return self._forward(x)
+
+class InitLayer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ idp,
+ num_types: int,
+ n_radial_basis: int,
+ r_max: float,
+ irreps_sh: o3.Irreps=None,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ two_body_latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ device: Union[str, torch.device] = torch.device("cpu"),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(InitLayer, self).__init__()
+ SCALAR = o3.Irrep("0e")
+ self.num_types = num_types
+ if isinstance(r_max, float) or isinstance(r_max, int):
+ self.r_max = torch.tensor(r_max, device=device, dtype=dtype)
+ self.r_max_dict = None
+ elif isinstance(r_max, dict):
+ c_set = set(list(r_max.values()))
+ self.r_max = torch.tensor(max(list(r_max.values())), device=device, dtype=dtype)
+ if len(r_max) == 1 or len(c_set) == 1:
+ self.r_max_dict = None
+ else:
+ self.r_max_dict = {}
+ for k,v in r_max.items():
+ self.r_max_dict[k] = torch.tensor(v, device=device, dtype=dtype)
+ else:
+ raise TypeError("r_max should be either float, int or dict")
+
+ self.idp = idp
+ self.two_body_latent_kwargs = two_body_latent_kwargs
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = PolynomialCutoff_p
+ self.cutoff_type = cutoff_type
+ self.device = device
+ self.dtype = dtype
+ self.irreps_out = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+ # env_embed_irreps = o3.Irreps([(1, ir) for _, ir in irreps_sh])
+ assert (
+ irreps_sh[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+
+ # Node invariants for center and neighbor (chemistry)
+ # Plus edge invariants for the edge (radius).
+ self.two_body_latent = ScalarMLPFunction(
+ mlp_input_dimension=(2 * num_types + n_radial_basis),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=self.irreps_out,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element", # if path normalization is element and input irreps has 1 mul, it should not have effect !
+ )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # instance=False,
+ # normalization="component",
+ # )
+
+ self.env_embed_mlp = ScalarMLPFunction(
+ mlp_input_dimension=self.two_body_latent.out_features,
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ **env_embed_kwargs,
+ )
+ self.bessel = BesselBasis(r_max=self.r_max, num_basis=n_radial_basis, trainable=True)
+
+
+
+ def forward(self, edge_index, bond_type, edge_sh, edge_length, node_one_hot):
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ edge_invariants = self.bessel(edge_length)
+ node_invariants = node_one_hot
+
+ # Vectorized precompute per layer cutoffs
+ if self.r_max_dict is None:
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs = cosine_cutoff(
+ edge_length,
+ self.r_max.reshape(-1),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs = polynomial_cutoff(
+ edge_length, self.r_max.reshape(-1), p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+ else:
+ cutoff_coeffs = torch.zeros(edge_index.shape[1], dtype=self.dtype, device=self.device)
+
+ for bond, ty in self.idp.bond_to_type.items():
+ mask = bond_type == ty
+ index = mask.nonzero().squeeze(-1)
+
+ if mask.any():
+ iatom, jatom = bond.split("-")
+ if self.cutoff_type == "cosine":
+ c_coeff = cosine_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+ elif self.cutoff_type == "polynomial":
+ c_coeff = polynomial_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ cutoff_coeffs = torch.index_copy(cutoff_coeffs, 0, index, c_coeff)
+
+ # Determine which edges are still in play
+ prev_mask = cutoff_coeffs > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ latents = torch.zeros(
+ (edge_sh.shape[0], self.two_body_latent.out_features),
+ dtype=edge_sh.dtype,
+ device=edge_sh.device,
+ )
+
+ new_latents = self.two_body_latent(torch.cat([
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ], dim=-1)[prev_mask])
+
+ # Apply cutoff, which propagates through to everything else
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+ weights = self.env_embed_mlp(latents[active_edges])
+
+ # embed initial edge
+ features = self._env_weighter(
+ edge_sh[prev_mask], weights
+ ) # features is edge_attr
+ # features = self.bn(features)
+
+ return latents, features, cutoff_coeffs, active_edges # the radial embedding x and the sperical hidden V
+
+class Layer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ num_types: int,
+ avg_num_neighbors: Optional[float] = None,
+ irreps_sh: o3.Irreps=None,
+ irreps_in: o3.Irreps=None,
+ irreps_out: o3.Irreps=None,
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_in: int=1024,
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ ):
+ super().__init__()
+ SCALAR = o3.Irrep("0e")
+ self.latent_resnet = latent_resnet
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.irreps_in = irreps_in
+ self.irreps_out = irreps_out
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor(avg_num_neighbors).rsqrt(),
+ )
+
+ latent = functools.partial(ScalarMLPFunction, **latent_kwargs)
+
+ self.latents = None
+ self.env_embed_mlps = None
+ self.tps = None
+ self.linears = None
+ self.env_linears = None
+
+ # Prune impossible paths
+ self.irreps_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in self.irreps_out
+ if tp_path_exists(irreps_sh, irreps_in, ir)
+ ]
+ )
+
+ mul_irreps_sh = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=mul_irreps_sh,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element",
+ )
+
+ # == Remove unneeded paths ==
+ #TODO: add the remove unseen paths
+
+ if self.linear_after_env_embed:
+ self.env_linears = Linear(
+ mul_irreps_sh,
+ mul_irreps_sh,
+ shared_weights=True,
+ internal_weights=True,
+ )
+ else:
+ self.env_linears = torch.nn.Identity()
+
+ # Make TP
+ tmp_i_out: int = 0
+ instr = []
+ n_scalar_outs: int = 0
+ n_scalar_mul = []
+ full_out_irreps = []
+ for i_out, (mul_out, ir_out) in enumerate(self.irreps_out):
+ for i_1, (mul1, ir_1) in enumerate(self.irreps_in): # what if feature_irreps_in has mul?
+ for i_2, (mul2, ir_2) in enumerate(self._env_weighter.irreps_out+self._env_weighter.irreps_out):
+ if ir_out in ir_1 * ir_2:
+ if ir_out == SCALAR:
+ n_scalar_outs += 1
+ n_scalar_mul.append(mul2)
+ # assert mul_out == mul1 == mul2
+ instr.append((i_1, i_2, tmp_i_out, 'uvv', True))
+ full_out_irreps.append((mul2, ir_out))
+ assert full_out_irreps[-1][0] == mul2
+ tmp_i_out += 1
+ full_out_irreps = o3.Irreps(full_out_irreps)
+ assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ self.n_scalar_mul = sum(n_scalar_mul)
+
+ self.lin_pre = Linear(
+ irreps_in=self.irreps_in,
+ irreps_out=self.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ self.tp = TensorProduct(
+ irreps_in1=o3.Irreps(
+ [(mul, ir) for mul, ir in self.irreps_in]
+ ),
+ irreps_in2=o3.Irreps(
+ [(mul, ir) for mul, ir in self._env_weighter.irreps_out+self._env_weighter.irreps_out]
+ ),
+ irreps_out=o3.Irreps(
+ [(mul, ir) for mul, ir in full_out_irreps]
+ ),
+ irrep_normalization="component",
+ instructions=instr,
+ shared_weights=True,
+ internal_weights=True,
+ )
+
+
+
+ # self.sc = FullyConnectedTensorProduct(
+ # irreps_in,
+ # o3.Irreps(str(2*num_types)+"x0e"),
+ # self.irreps_out,
+ # shared_weights=True,
+ # internal_weights=True
+ # )
+
+ self.lin_post = Linear(
+ self.irreps_out,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ self.bn = BatchNorm(
+ irreps=self.irreps_out,
+ affine=True,
+ instance=False,
+ normalization="component",
+ )
+
+ self.linear_res = Linear(
+ self.irreps_in,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # build activation
+ irreps_scalar = o3.Irreps(str(self.irreps_out[0]))
+ irreps_gated = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l > 0]).simplify()
+ irreps_gates = o3.Irreps([(mul, (0,1)) for mul, _ in irreps_gated]).simplify()
+ act={1: torch.nn.functional.silu, -1: torch.tanh}
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+
+ self.activation = Gate(
+ irreps_scalar, [act[ir.p] for _, ir in irreps_scalar], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ # we extract the scalars from the first irrep of the tp
+ assert self.irreps_out[0].ir == SCALAR
+ self.linears = Linear(
+ irreps_in=full_out_irreps,
+ irreps_out=self.activation.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # the embedded latent invariants from the previous layer(s)
+ # and the invariants extracted from the last layer's TP:
+ self.latents = latent(
+ mlp_input_dimension=latent_in+self.n_scalar_mul,
+ mlp_output_dimension=None,
+ )
+
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ )
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(1)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios > 0.0
+ assert latent_resnet_update_ratios < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ def forward(self, edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges):
+ # update V
+ # update X
+ # edge_index: [2, num_edges]
+ # irreps_sh: [num_edges, irreps_sh]
+ # latents: [num_edges, latent_in]
+ # fetures: [num_active_edges, in_irreps]
+ # cutoff_coeffs: [num_edges]
+ # active_edges: [num_active_edges]
+
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ prev_mask = cutoff_coeffs > 0
+
+ # sc_features = self.sc(features, node_one_hot[edge_index].transpose(0,1).flatten(1,2)[active_edges])
+ # update V
+ weights = self.env_embed_mlps(latents[active_edges])
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_sh[active_edges], weights),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ # currently, we have a sum over neighbors of constant number for each layer,
+ # the env_sum_normalization can be a scalar or list
+ # the different cutoff can be added in the future
+
+ if self.env_sum_normalizations.ndim < 1:
+ norm_const = self.env_sum_normalizations
+ else:
+ norm_const = self.env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = self.env_linears(local_env_per_edge)
+
+ # local_env_per_edge = torch.cat([local_env_per_edge[edge_center[active_edges]], local_env_per_edge[edge_neighbor[active_edges]]], dim=-1)
+ local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ new_features = self.tp(
+ self.lin_pre(features),
+ torch.cat(
+ [
+ local_env_per_edge[edge_center[active_edges]],
+ local_env_per_edge[edge_neighbor[active_edges]]
+ ], dim=-1
+ )) # full_out_irreps
+
+
+ # features has shape [N_edge, full_feature_out.dim]
+ # we know scalars are first
+ scalars = new_features[:, :self.n_scalar_mul]
+ assert len(scalars.shape) == 2
+
+ # do the linear
+ new_features = self.linears(new_features)
+ new_features = self.activation(new_features)
+
+ new_features = self.lin_post(new_features)
+
+ new_features = self.bn(new_features)
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ features = coefficient_new * new_features + coefficient_old * self.linear_res(features)
+ else:
+ features = new_features
+
+ # update X
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ new_latents = self.latents(torch.cat(latent_inputs_to_cat, dim=-1))
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ return latents, features, cutoff_coeffs, active_edges
\ No newline at end of file
diff --git a/dptb/nn/embedding/e3baseline_local.py b/dptb/nn/embedding/e3baseline_local.py
new file mode 100644
index 00000000..f4971ad6
--- /dev/null
+++ b/dptb/nn/embedding/e3baseline_local.py
@@ -0,0 +1,1056 @@
+from typing import Optional, List, Union, Dict
+import math
+import functools
+import warnings
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from dptb.nn.norm import TypeNorm
+from e3nn import o3
+from e3nn.nn import Gate
+from e3nn.nn._batchnorm import BatchNorm
+from torch_scatter import scatter_mean
+from e3nn.o3 import Linear, SphericalHarmonics
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+from dptb.nn.rescale import E3PerSpeciesScaleShift, E3PerEdgeSpeciesScaleShift
+
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..radial_basis import BesselBasis
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.nn.embedding.from_deephe3.e3module import SeparateWeightTensorProduct
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+from dptb.nn.rescale import E3ElementLinear
+import math
+from dptb.data.transforms import OrbitalMapper
+from ..type_encode.one_hot import OneHotAtomEncoding
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+
+from math import ceil
+
+@Embedding.register("e3baseline_local")
+class E3BaseLineModelLocal(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ # required params
+ n_atom: int=1,
+ n_layers: int=3,
+ n_radial_basis: int=10,
+ r_max: float=5.0,
+ lmax: int=4,
+ irreps_hidden: o3.Irreps=None,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ sh_normalized: bool = True,
+ sh_normalization: str = "component",
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [256, 256, 512],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+
+ super(E3BaseLineModelLocal, self).__init__()
+
+ irreps_hidden = o3.Irreps(irreps_hidden)
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ if isinstance(device, str):
+ device = torch.device(device)
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_irreps(no_parity=False)
+ self.n_atom = n_atom
+
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ orbpair_irreps = self.idp.orbpair_irreps.sort()[0].simplify()
+
+ # check if the irreps setting satisfied the requirement of idp
+ irreps_out = []
+ for mul, ir1 in irreps_hidden:
+ for _, ir2 in orbpair_irreps:
+ irreps_out += [o3.Irrep(str(irr)) for irr in ir1*ir2]
+ irreps_out = o3.Irreps(irreps_out).sort()[0].simplify()
+
+ assert all(ir in irreps_out for _, ir in orbpair_irreps), "hidden irreps should at least cover all the reqired irreps in the hamiltonian data {}".format(orbpair_irreps)
+
+ # TODO: check if the tp in first layer can produce the required irreps for hidden states
+
+ self.sh = SphericalHarmonics(
+ irreps_sh, sh_normalized, sh_normalization
+ )
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ self.init_layer = InitLayer(
+ idp=self.idp,
+ num_types=n_atom,
+ n_radial_basis=n_radial_basis,
+ r_max=r_max,
+ irreps_sh=irreps_sh,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ two_body_latent_kwargs=latent_kwargs,
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio=r_start_cos_ratio,
+ PolynomialCutoff_p=PolynomialCutoff_p,
+ cutoff_type=cutoff_type,
+ device=device,
+ dtype=dtype,
+ )
+
+ self.layers = torch.nn.ModuleList()
+ latent_in =latent_kwargs["mlp_latent_dimensions"][-1]
+ # actually, we can derive the least required irreps_in and out from the idp's node and pair irreps
+ last_layer = False
+ for i in range(n_layers):
+ if i == 0:
+ irreps_in = self.init_layer.irreps_out
+ else:
+ irreps_in = irreps_hidden
+
+ if i == n_layers - 1:
+ irreps_out = orbpair_irreps.sort()[0].simplify()
+ last_layer = True
+ else:
+ irreps_out = irreps_hidden
+
+ self.layers.append(Layer(
+ num_types=n_atom,
+ avg_num_neighbors=avg_num_neighbors,
+ irreps_sh=irreps_sh,
+ irreps_in=irreps_in,
+ irreps_out=irreps_out,
+ # general hyperparameters:
+ linear_after_env_embed=linear_after_env_embed,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ latent_kwargs=latent_kwargs,
+ latent_in=latent_in,
+ latent_resnet=latent_resnet,
+ latent_resnet_update_ratios=latent_resnet_update_ratios,
+ latent_resnet_update_ratios_learnable=latent_resnet_update_ratios_learnable,
+ last_layer=last_layer,
+ dtype=dtype,
+ device=device,
+ )
+ )
+
+ # initilize output_layer
+ self.out_edge = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+
+ @property
+ def out_edge_irreps(self):
+ return self.idp.orbpair_irreps
+
+ @property
+ def out_node_irreps(self):
+ return self.idp.orbpair_irreps
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ # data = with_env_vectors(data, with_lengths=True)
+ data = with_batch(data)
+ batch = data[_keys.BATCH_KEY]
+
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_sh = self.sh(data[_keys.EDGE_VECTORS_KEY][:,[1,2,0]])
+ edge_length = data[_keys.EDGE_LENGTH_KEY]
+
+
+ data = self.onehot(data)
+ node_one_hot = data[_keys.NODE_ATTRS_KEY]
+ atom_type = data[_keys.ATOM_TYPE_KEY].flatten()
+ bond_type = data[_keys.EDGE_TYPE_KEY].flatten()
+ latents, features, cutoff_coeffs, active_edges = self.init_layer(edge_index, bond_type, edge_sh, edge_length, node_one_hot)
+
+ for layer in self.layers:
+ latents, features, cutoff_coeffs, active_edges = layer(edge_index, edge_sh, atom_type, bond_type, latents, features, cutoff_coeffs, active_edges, batch)
+
+ data[_keys.NODE_FEATURES_KEY] = self.out_node(latents)
+ data[_keys.EDGE_FEATURES_KEY] = torch.zeros(edge_index.shape[1], self.idp.orbpair_irreps.dim, dtype=self.dtype, device=self.device)
+ data[_keys.EDGE_FEATURES_KEY] = torch.index_copy(data[_keys.EDGE_FEATURES_KEY], 0, active_edges, self.out_edge(features))
+
+ return data
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = o3.Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+@compile_mode("script")
+class MakeWeightedChannels(torch.nn.Module):
+ weight_numel: int
+ multiplicity_out: Union[int, list]
+ _num_irreps: int
+
+ def __init__(
+ self,
+ irreps_in: o3.Irreps,
+ multiplicity_out: Union[int, list],
+ pad_to_alignment: int = 1,
+ ):
+ super().__init__()
+ assert all(mul == 1 for mul, _ in irreps_in)
+ assert multiplicity_out >= 1
+ # Each edgewise output multiplicity is a per-irrep weighted sum over the input
+ # So we need to apply the weight for the ith irrep to all DOF in that irrep
+ w_index = []
+ idx = 0
+ self._num_irreps = 0
+ for (mul, ir) in irreps_in:
+ w_index += sum(([ix] * ir.dim for ix in range(idx, idx + mul)), [])
+ idx += mul
+ self._num_irreps += mul
+ # w_index = sum(([i] * ir.dim for i, (mul, ir) in enumerate(irreps_in)), [])
+ # pad to padded length
+ n_pad = (
+ int(ceil(irreps_in.dim / pad_to_alignment)) * pad_to_alignment
+ - irreps_in.dim
+ )
+ # use the last weight, what we use doesn't matter much
+ w_index += [w_index[-1]] * n_pad
+ self.register_buffer("_w_index", torch.as_tensor(w_index, dtype=torch.long))
+ # there is
+ self.multiplicity_out = multiplicity_out
+ self.weight_numel = self._num_irreps * multiplicity_out
+
+ def forward(self, edge_attr, weights):
+ # weights are [z, u, num_i]
+ # edge_attr are [z, i]
+ # i runs over all irreps, which is why the weights need
+ # to be indexed in order to go from [num_i] to [i]
+ return torch.einsum(
+ "zi,zui->zui",
+ edge_attr,
+ weights.view(
+ -1,
+ self.multiplicity_out,
+ self._num_irreps,
+ )[:, :, self._w_index],
+ )
+
+@torch.jit.script
+def ShiftedSoftPlus(x: torch.Tensor):
+ return torch.nn.functional.softplus(x) - math.log(2.0)
+
+class ScalarMLPFunction(CodeGenMixin, torch.nn.Module):
+ """Module implementing an MLP according to provided options."""
+
+ in_features: int
+ out_features: int
+
+ def __init__(
+ self,
+ mlp_input_dimension: Optional[int],
+ mlp_latent_dimensions: List[int],
+ mlp_output_dimension: Optional[int],
+ mlp_nonlinearity: Optional[str] = "silu",
+ mlp_initialization: str = "normal",
+ mlp_dropout_p: float = 0.0,
+ mlp_batchnorm: bool = False,
+ ):
+ super().__init__()
+ nonlinearity = {
+ None: None,
+ "silu": torch.nn.functional.silu,
+ "ssp": ShiftedSoftPlus,
+ }[mlp_nonlinearity]
+ if nonlinearity is not None:
+ nonlin_const = normalize2mom(nonlinearity).cst
+ else:
+ nonlin_const = 1.0
+
+ dimensions = (
+ ([mlp_input_dimension] if mlp_input_dimension is not None else [])
+ + mlp_latent_dimensions
+ + ([mlp_output_dimension] if mlp_output_dimension is not None else [])
+ )
+ assert len(dimensions) >= 2 # Must have input and output dim
+ num_layers = len(dimensions) - 1
+
+ self.in_features = dimensions[0]
+ self.out_features = dimensions[-1]
+
+ # Code
+ params = {}
+ graph = fx.Graph()
+ tracer = fx.proxy.GraphAppendingTracer(graph)
+
+ def Proxy(n):
+ return fx.Proxy(n, tracer=tracer)
+
+ features = Proxy(graph.placeholder("x"))
+ norm_from_last: float = 1.0
+
+ base = torch.nn.Module()
+
+ for layer, (h_in, h_out) in enumerate(zip(dimensions, dimensions[1:])):
+ # do dropout
+ if mlp_dropout_p > 0:
+ # only dropout if it will do something
+ # dropout before linear projection- https://stats.stackexchange.com/a/245137
+ features = Proxy(graph.call_module("_dropout", (features.node,)))
+
+ # make weights
+ w = torch.empty(h_in, h_out)
+
+ if mlp_initialization == "normal":
+ w.normal_()
+ elif mlp_initialization == "uniform":
+ # these values give < x^2 > = 1
+ w.uniform_(-math.sqrt(3), math.sqrt(3))
+ elif mlp_initialization == "orthogonal":
+ # this rescaling gives < x^2 > = 1
+ torch.nn.init.orthogonal_(w, gain=math.sqrt(max(w.shape)))
+ else:
+ raise NotImplementedError(
+ f"Invalid mlp_initialization {mlp_initialization}"
+ )
+
+ # generate code
+ params[f"_weight_{layer}"] = w
+ w = Proxy(graph.get_attr(f"_weight_{layer}"))
+ w = w * (
+ norm_from_last / math.sqrt(float(h_in))
+ ) # include any nonlinearity normalization from previous layers
+ features = torch.matmul(features, w)
+
+ if mlp_batchnorm:
+ # if we call batchnorm, do it after the nonlinearity
+ features = Proxy(graph.call_module(f"_bn_{layer}", (features.node,)))
+ setattr(base, f"_bn_{layer}", torch.nn.BatchNorm1d(h_out))
+
+ # generate nonlinearity code
+ if nonlinearity is not None and layer < num_layers - 1:
+ features = nonlinearity(features)
+ # add the normalization const in next layer
+ norm_from_last = nonlin_const
+
+ graph.output(features.node)
+
+ for pname, p in params.items():
+ setattr(base, pname, torch.nn.Parameter(p))
+
+ if mlp_dropout_p > 0:
+ # with normal dropout everything blows up
+ base._dropout = torch.nn.AlphaDropout(p=mlp_dropout_p)
+
+ self._codegen_register({"_forward": fx.GraphModule(base, graph)})
+
+ def forward(self, x):
+ return self._forward(x)
+
+class InitLayer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ idp,
+ num_types: int,
+ n_radial_basis: int,
+ r_max: float,
+ irreps_sh: o3.Irreps=None,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ two_body_latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ device: Union[str, torch.device] = torch.device("cpu"),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(InitLayer, self).__init__()
+ SCALAR = o3.Irrep("0e")
+ self.num_types = num_types
+ if isinstance(r_max, float) or isinstance(r_max, int):
+ self.r_max = torch.tensor(r_max, device=device, dtype=dtype)
+ self.r_max_dict = None
+ elif isinstance(r_max, dict):
+ c_set = set(list(r_max.values()))
+ self.r_max = torch.tensor(max(list(r_max.values())), device=device, dtype=dtype)
+ if len(r_max) == 1 or len(c_set) == 1:
+ self.r_max_dict = None
+ else:
+ self.r_max_dict = {}
+ for k,v in r_max.items():
+ self.r_max_dict[k] = torch.tensor(v, device=device, dtype=dtype)
+ else:
+ raise TypeError("r_max should be either float, int or dict")
+
+ self.idp = idp
+ self.two_body_latent_kwargs = two_body_latent_kwargs
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = PolynomialCutoff_p
+ self.cutoff_type = cutoff_type
+ self.device = device
+ self.dtype = dtype
+ self.irreps_out = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+ # env_embed_irreps = o3.Irreps([(1, ir) for _, ir in irreps_sh])
+ assert (
+ irreps_sh[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+
+ # Node invariants for center and neighbor (chemistry)
+ # Plus edge invariants for the edge (radius).
+ self.two_body_latent = ScalarMLPFunction(
+ mlp_input_dimension=(2 * num_types + n_radial_basis),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=self.irreps_out,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element", # if path normalization is element and input irreps has 1 mul, it should not have effect !
+ )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # instance=False,
+ # normalization="component",
+ # )
+
+ self.env_embed_mlp = ScalarMLPFunction(
+ mlp_input_dimension=self.two_body_latent.out_features,
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ **env_embed_kwargs,
+ )
+
+ self.bessel = BesselBasis(r_max=self.r_max, num_basis=n_radial_basis, trainable=True)
+
+
+
+ def forward(self, edge_index, bond_type, edge_sh, edge_length, node_one_hot):
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ edge_invariants = self.bessel(edge_length)
+ node_invariants = node_one_hot
+
+ # Vectorized precompute per layer cutoffs
+ if self.r_max_dict is None:
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs = cosine_cutoff(
+ edge_length,
+ self.r_max.reshape(-1),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs = polynomial_cutoff(
+ edge_length, self.r_max.reshape(-1), p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+ else:
+ cutoff_coeffs = torch.zeros(edge_index.shape[1], dtype=self.dtype, device=self.device)
+
+ for bond, ty in self.idp.bond_to_type.items():
+ mask = bond_type == ty
+ index = mask.nonzero().squeeze(-1)
+
+ if mask.any():
+ iatom, jatom = bond.split("-")
+ if self.cutoff_type == "cosine":
+ c_coeff = cosine_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+ elif self.cutoff_type == "polynomial":
+ c_coeff = polynomial_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ cutoff_coeffs = torch.index_copy(cutoff_coeffs, 0, index, c_coeff)
+
+ # Determine which edges are still in play
+ prev_mask = cutoff_coeffs > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ latents = torch.zeros(
+ (edge_sh.shape[0], self.two_body_latent.out_features),
+ dtype=edge_sh.dtype,
+ device=edge_sh.device,
+ )
+
+ new_latents = self.two_body_latent(torch.cat([
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ], dim=-1)[prev_mask])
+
+ # Apply cutoff, which propagates through to everything else
+ latents = torch.index_copy(
+ latents, 0, active_edges,
+ cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ )
+ weights = self.env_embed_mlp(new_latents)
+
+ # embed initial edge
+ features = self._env_weighter(
+ edge_sh[prev_mask], weights
+ ) # features is edge_attr
+ # features = self.bn(features)
+
+ return latents, features, cutoff_coeffs, active_edges # the radial embedding x and the sperical hidden V
+
+class Layer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ num_types: int,
+ avg_num_neighbors: Optional[float] = None,
+ irreps_sh: o3.Irreps=None,
+ irreps_in: o3.Irreps=None,
+ irreps_out: o3.Irreps=None,
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_in: int=1024,
+ latent_resnet: bool = True,
+ last_layer: bool = False,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+ super().__init__()
+
+ assert latent_in == latent_kwargs["mlp_latent_dimensions"][-1]
+
+ SCALAR = o3.Irrep("0e")
+ self.latent_resnet = latent_resnet
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.irreps_in = irreps_in
+ self.irreps_out = irreps_out
+ self.last_layer = last_layer
+ self.dtype = dtype
+ self.device = device
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor(avg_num_neighbors).rsqrt(),
+ )
+
+ latent = functools.partial(ScalarMLPFunction, **latent_kwargs)
+
+ self.latents = None
+ self.env_embed_mlps = None
+ self.tps = None
+ self.linears = None
+ self.env_linears = None
+
+ # Prune impossible paths
+ self.irreps_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in self.irreps_out
+ if tp_path_exists(irreps_sh, irreps_in, ir)
+ ]
+ )
+
+ mul_irreps_sh = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=mul_irreps_sh,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element",
+ )
+
+ if last_layer:
+ self._node_weighter = E3ElementLinear(
+ irreps_in=irreps_out,
+ dtype=dtype,
+ device=device,
+ )
+
+ self._edge_weighter = E3ElementLinear(
+ irreps_in=irreps_out,
+ dtype=dtype,
+ device=device,
+ )
+
+ # == Remove unneeded paths ==
+ #TODO: add the remove unseen paths
+
+ if self.linear_after_env_embed:
+ self.env_linears = Linear(
+ mul_irreps_sh,
+ mul_irreps_sh,
+ shared_weights=True,
+ internal_weights=True,
+ )
+
+ else:
+ self.env_linears = torch.nn.Identity()
+
+ # # Make TP
+ # tmp_i_out: int = 0
+ # instr = []
+ # n_scalar_outs: int = 0
+ # n_scalar_mul = []
+ # full_out_irreps = []
+ # for i_out, (mul_out, ir_out) in enumerate(self.irreps_out):
+ # for i_1, (mul1, ir_1) in enumerate(self.irreps_in): # what if feature_irreps_in has mul?
+ # for i_2, (mul2, ir_2) in enumerate(self._env_weighter.irreps_out):
+ # if ir_out in ir_1 * ir_2:
+ # if ir_out == SCALAR:
+ # n_scalar_outs += 1
+ # n_scalar_mul.append(mul2)
+ # # assert mul_out == mul1 == mul2
+ # instr.append((i_1, i_2, tmp_i_out, 'uvv', True))
+ # full_out_irreps.append((mul2, ir_out))
+ # assert full_out_irreps[-1][0] == mul2
+ # tmp_i_out += 1
+ # full_out_irreps = o3.Irreps(full_out_irreps)
+ # assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ # self.n_scalar_mul = sum(n_scalar_mul)
+
+ self.lin_pre = Linear(
+ irreps_in=self.irreps_in,
+ irreps_out=self.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.tp = TensorProduct(
+ # irreps_in1=o3.Irreps(
+ # [(mul, ir) for mul, ir in self.irreps_in]
+ # ),
+ # irreps_in2=o3.Irreps(
+ # [(mul, ir) for mul, ir in self._env_weighter.irreps_out]
+ # ),
+ # irreps_out=o3.Irreps(
+ # [(mul, ir) for mul, ir in full_out_irreps]
+ # ),
+ # irrep_normalization="component",
+ # instructions=instr,
+ # shared_weights=True,
+ # internal_weights=True,
+ # )
+ # build activation
+
+ irreps_scalar = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l == 0]).simplify()
+ irreps_gated = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l > 0]).simplify()
+
+
+ irreps_gates = o3.Irreps([(mul, (0,1)) for mul, _ in irreps_gated]).simplify()
+ act={1: torch.nn.functional.silu, -1: torch.tanh}
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+
+ self.activation = Gate(
+ irreps_scalar, [act[ir.p] for _, ir in irreps_scalar], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ self.tp = SeparateWeightTensorProduct(
+ irreps_in1=self.irreps_in,
+ irreps_in2=self._env_weighter.irreps_out,
+ irreps_out=self.activation.irreps_in,
+ )
+
+ if self.last_layer:
+ self.tp_out = SeparateWeightTensorProduct(
+ irreps_in1=self.irreps_out+self._env_weighter.irreps_out+self._env_weighter.irreps_out,
+ irreps_in2=irreps_sh,
+ irreps_out=self.irreps_out,
+ )
+
+ # self.sc = FullyConnectedTensorProduct(
+ # irreps_in,
+ # o3.Irreps(str(2*num_types)+"x0e"),
+ # self.irreps_out,
+ # shared_weights=True,
+ # internal_weights=True
+ # )
+
+ self.lin_post = Linear(
+ self.activation.irreps_out,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.bn = TypeNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # num_type=num_types*num_types,
+ # normalization="component",
+ # )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # normalization="component",
+ # )
+
+ if latent_resnet:
+ self.linear_res = Linear(
+ self.irreps_in,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # we extract the scalars from the first irrep of the tp
+ # assert full_out_irreps[0].ir == SCALAR
+ # self.linears = Linear(
+ # irreps_in=full_out_irreps,
+ # irreps_out=self.activation.irreps_in,
+ # shared_weights=True,
+ # internal_weights=True,
+ # biases=True,
+ # )
+
+ # the embedded latent invariants from the previous layer(s)
+ # and the invariants extracted from the last layer's TP:
+ # we need to make sure all scalars in tp.irreps_out all contains in the first irreps
+ all_tp_scalar = o3.Irreps([(mul, ir) for mul, ir in self.tp.irreps_out if ir.l == 0]).simplify()
+ assert all_tp_scalar.dim == self.tp.irreps_out[0].dim
+ self.latents = latent(
+ mlp_input_dimension=latent_in+self.tp.irreps_out[0].dim,
+ mlp_output_dimension=None,
+ )
+
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ )
+
+ if last_layer:
+ self.node_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._node_weighter.weight_numel,
+ )
+
+ self.edge_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._edge_weighter.weight_numel,
+ )
+
+ # self.node_bn = TypeNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # num_type=num_types,
+ # normalization="component",
+ # )
+
+ # self.node_bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # normalization="norm",
+ # )
+
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(1)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios > 0.0
+ assert latent_resnet_update_ratios < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ def forward(self, edge_index, edge_sh, atom_type, bond_type, latents, features, cutoff_coeffs, active_edges, batch):
+ # update V
+ # update X
+ # edge_index: [2, num_edges]
+ # irreps_sh: [num_edges, irreps_sh]
+ # latents: [num_edges, latent_in]
+ # fetures: [num_active_edges, in_irreps]
+ # cutoff_coeffs: [num_edges]
+ # active_edges: [num_active_edges]
+
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ prev_mask = cutoff_coeffs > 0
+
+ # sc_features = self.sc(features, node_one_hot[edge_index].transpose(0,1).flatten(1,2)[active_edges])
+ # update V
+ weights = self.env_embed_mlps(latents[active_edges])
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_sh[active_edges], weights),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ # currently, we have a sum over neighbors of constant number for each layer,
+ # the env_sum_normalization can be a scalar or list
+ # the different cutoff can be added in the future
+
+ if self.env_sum_normalizations.ndim < 1:
+ norm_const = self.env_sum_normalizations
+ else:
+ norm_const = self.env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = self.env_linears(local_env_per_edge)
+
+ # local_env_per_edge = torch.cat([local_env_per_edge[edge_center[active_edges]], local_env_per_edge[edge_neighbor[active_edges]]], dim=-1)
+ # local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ new_features = self.tp(self.lin_pre(features), local_env_per_edge[edge_center[active_edges]]) # full_out_irreps
+
+ scalars = new_features[:, :self.tp.irreps_out[0].dim]
+ new_features = self.activation(new_features)
+ # # do the linear
+ # new_features = self.linears(new_features)
+
+
+ # features has shape [N_edge, full_feature_out.dim]
+ # we know scalars are first
+ assert len(scalars.shape) == 2
+
+ new_features = self.lin_post(new_features)
+
+ # new_features = self.bn(new_features, bond_type[active_edges])
+ # new_features = new_features - scatter_mean(new_features, batch[edge_center[active_edges]], dim=0, dim_size=batch.max()+1)[batch[edge_center[active_edges]]]
+ # new_features = self.bn(new_features)
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ features = coefficient_new * new_features + coefficient_old * self.linear_res(features)
+ else:
+ features = new_features
+
+ # whether it is the last layer
+
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ new_latents = self.latents(torch.cat(latent_inputs_to_cat, dim=-1))
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ if self.last_layer:
+ node_weights = self.node_embed_mlps(latents[active_edges])
+
+ node_features = scatter(
+ self._node_weighter(
+ features,
+ node_weights,
+ ),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ node_features = node_features * norm_const
+
+ # node_features = self.node_bn(node_features, atom_type)
+ # node_features = self.node_bn(node_features)
+
+ edge_weights = self.edge_embed_mlps(latents[active_edges])
+
+ # the features's inclusion of the radial weight here is the only place
+ # where features are weighted according to the radial distance
+ features = self.tp_out(
+ torch.cat(
+ [
+ features,
+ local_env_per_edge[edge_center[active_edges]],
+ local_env_per_edge[edge_neighbor[active_edges]],
+ ], dim=-1
+ ),
+ edge_sh[active_edges],
+ )
+
+ features = self._edge_weighter(
+ features,
+ edge_weights,
+ )
+
+ return node_features, features, cutoff_coeffs, active_edges
+ else:
+ return latents, features, cutoff_coeffs, active_edges
+
\ No newline at end of file
diff --git a/dptb/nn/embedding/e3baseline_local1.py b/dptb/nn/embedding/e3baseline_local1.py
new file mode 100644
index 00000000..cd126a4b
--- /dev/null
+++ b/dptb/nn/embedding/e3baseline_local1.py
@@ -0,0 +1,1136 @@
+from typing import Optional, List, Union, Dict
+import math
+import functools
+import warnings
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from dptb.nn.norm import TypeNorm
+from e3nn import o3
+from e3nn.nn import Gate
+from e3nn.nn._batchnorm import BatchNorm
+from torch_scatter import scatter_mean
+from e3nn.o3 import Linear, SphericalHarmonics
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+from dptb.nn.rescale import E3PerSpeciesScaleShift, E3PerEdgeSpeciesScaleShift
+
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..radial_basis import BesselBasis
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.nn.embedding.from_deephe3.e3module import SeparateWeightTensorProduct
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+from dptb.nn.rescale import E3ElementLinear
+import math
+from dptb.data.transforms import OrbitalMapper
+from ..type_encode.one_hot import OneHotAtomEncoding
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+
+from math import ceil
+
+@Embedding.register("e3baseline_local_wnode")
+class E3BaseLineModelLocal1(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ # required params
+ n_atom: int=1,
+ n_layers: int=3,
+ n_radial_basis: int=10,
+ r_max: float=5.0,
+ lmax: int=4,
+ irreps_hidden: o3.Irreps=None,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ sh_normalized: bool = True,
+ sh_normalization: str = "component",
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [256, 256, 512],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+
+ super(E3BaseLineModelLocal1, self).__init__()
+
+ irreps_hidden = o3.Irreps(irreps_hidden)
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ if isinstance(device, str):
+ device = torch.device(device)
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_irreps(no_parity=False)
+ self.n_atom = n_atom
+
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ orbpair_irreps = self.idp.orbpair_irreps.sort()[0].simplify()
+
+ # check if the irreps setting satisfied the requirement of idp
+ irreps_out = []
+ for mul, ir1 in irreps_hidden:
+ for _, ir2 in orbpair_irreps:
+ irreps_out += [o3.Irrep(str(irr)) for irr in ir1*ir2]
+ irreps_out = o3.Irreps(irreps_out).sort()[0].simplify()
+
+ assert all(ir in irreps_out for _, ir in orbpair_irreps), "hidden irreps should at least cover all the reqired irreps in the hamiltonian data {}".format(orbpair_irreps)
+
+ # TODO: check if the tp in first layer can produce the required irreps for hidden states
+
+ self.sh = SphericalHarmonics(
+ irreps_sh, sh_normalized, sh_normalization
+ )
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ self.init_layer = InitLayer(
+ idp=self.idp,
+ num_types=n_atom,
+ n_radial_basis=n_radial_basis,
+ r_max=r_max,
+ irreps_sh=irreps_sh,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ two_body_latent_kwargs=latent_kwargs,
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio=r_start_cos_ratio,
+ PolynomialCutoff_p=PolynomialCutoff_p,
+ cutoff_type=cutoff_type,
+ device=device,
+ dtype=dtype,
+ )
+
+ self.layers = torch.nn.ModuleList()
+ latent_in =latent_kwargs["mlp_latent_dimensions"][-1]
+ # actually, we can derive the least required irreps_in and out from the idp's node and pair irreps
+ last_layer = False
+ for i in range(n_layers):
+ if i == 0:
+ irreps_in = self.init_layer.irreps_out
+ else:
+ irreps_in = irreps_hidden
+
+ if i == n_layers - 1:
+ irreps_out = orbpair_irreps.sort()[0].simplify()
+ last_layer = True
+ else:
+ irreps_out = irreps_hidden
+
+ self.layers.append(Layer(
+ num_types=n_atom,
+ avg_num_neighbors=avg_num_neighbors,
+ irreps_sh=irreps_sh,
+ irreps_in=irreps_in,
+ irreps_out=irreps_out,
+ # general hyperparameters:
+ linear_after_env_embed=linear_after_env_embed,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ latent_kwargs=latent_kwargs,
+ latent_in=latent_in,
+ latent_resnet=latent_resnet,
+ latent_resnet_update_ratios=latent_resnet_update_ratios,
+ latent_resnet_update_ratios_learnable=latent_resnet_update_ratios_learnable,
+ last_layer=last_layer,
+ dtype=dtype,
+ device=device,
+ )
+ )
+
+ # initilize output_layer
+ sorted_irs = self.idp.orbpair_irreps.sort()[0]
+ irs = self.idp.orbpair_irreps
+ sorted_to_origin = []
+ for ind in self.idp.orbpair_irreps.sort().p:
+ ir = sorted_irs[ind]
+ sorted_to_origin += list(range(sorted_irs[:ind].dim, sorted_irs[:ind].dim+ir.dim))
+ self.sorted_to_origin = torch.LongTensor(sorted_to_origin)
+ self.out_edge = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node_mean = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node_var = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=False)
+ # self.out_node_var_norm = BatchNorm(
+ # irreps=self.out_node_irreps,
+ # affine=True,
+ # normalization="component",
+ # )
+
+ self.out_node_mean_scale = E3PerSpeciesScaleShift(
+ field=_keys.NODE_FEATURES_KEY,
+ num_types=n_atom,
+ irreps_in=self.out_node_irreps,
+ out_field = _keys.NODE_FEATURES_KEY,
+ shifts=0.,
+ scales=1.,
+ dtype=self.dtype,
+ device=self.device,
+ scales_trainable=True,
+ shifts_trainable=True,
+ )
+
+ self.out_node_var_scale = E3PerSpeciesScaleShift(
+ field=_keys.NODE_FEATURES_KEY,
+ num_types=n_atom,
+ irreps_in=self.out_node_irreps,
+ out_field = _keys.NODE_FEATURES_KEY,
+ shifts=None,
+ scales=1.,
+ dtype=self.dtype,
+ device=self.device,
+ scales_trainable=True,
+ shifts_trainable=True,
+ )
+
+ # self.out_edge_scale = E3PerEdgeSpeciesScaleShift(
+ # field=_keys.EDGE_FEATURES_KEY,
+ # num_types=n_atom,
+ # irreps_in=self.out_edge_irreps,
+ # out_field = _keys.EDGE_FEATURES_KEY,
+ # shifts=0.,
+ # scales=1.,
+ # dtype=self.dtype,
+ # device=self.device,
+ # scales_trainable=False,
+ # shifts_trainable=False,
+ # )
+
+ # self.node_bn = BatchNorm(
+ # irreps=self.out_node_irreps,
+ # affine=True,
+ # normalization="component",
+ # )
+
+ # self.nodetype_bn = TypeNorm(
+ # irreps=self.out_node_irreps,
+ # affine=True,
+ # num_type=n_atom,
+ # normalization="component",
+ # )
+
+ @property
+ def out_edge_irreps(self):
+ return self.idp.orbpair_irreps
+
+ @property
+ def out_node_irreps(self):
+ return self.idp.orbpair_irreps
+
+ # def set_out_scales(self, node_scales: torch.Tensor, node_shifts: torch.Tensor, edge_scales: torch.Tensor, edge_shifts: torch.Tensor):
+ # assert node_scales.shape == self.out_node_scale.scales.shape
+ # assert node_shifts.shape == self.out_node_scale.shifts.shape
+ # assert edge_scales.shape == self.out_edge_scale.scales.shape
+ # assert edge_shifts.shape == self.out_edge_scale.shifts.shape
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ # data = with_env_vectors(data, with_lengths=True)
+ data = with_batch(data)
+ batch = data[_keys.BATCH_KEY]
+
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_sh = self.sh(data[_keys.EDGE_VECTORS_KEY][:,[1,2,0]])
+ edge_length = data[_keys.EDGE_LENGTH_KEY]
+
+
+ data = self.onehot(data)
+ node_one_hot = data[_keys.NODE_ATTRS_KEY]
+ atom_type = data[_keys.ATOM_TYPE_KEY].flatten()
+ bond_type = data[_keys.EDGE_TYPE_KEY].flatten()
+ latents, features, cutoff_coeffs, active_edges = self.init_layer(edge_index, bond_type, edge_sh, edge_length, node_one_hot)
+
+ for layer in self.layers:
+ latents, features, cutoff_coeffs, active_edges = layer(edge_index, edge_sh, atom_type, bond_type, latents, features, cutoff_coeffs, active_edges, batch)
+ scatter_index = batch * self.n_atom + atom_type
+ latents_mean = scatter_mean(latents, scatter_index, dim=0, dim_size=(batch.max()+1)*self.n_atom)
+ latents_var = latents - latents_mean[scatter_index]
+ latents_mean = self.out_node_mean(latents_mean)[scatter_index]
+ latents_var = self.out_node_var(latents_var)
+
+ data[_keys.NODE_FEATURES_KEY] = latents_mean
+ latents_mean = self.out_node_mean_scale(data)[_keys.NODE_FEATURES_KEY]
+ data[_keys.NODE_FEATURES_KEY] = latents_var
+ data = self.out_node_var_scale(data)
+ data[_keys.NODE_FEATURES_KEY] = latents_mean + data[_keys.NODE_FEATURES_KEY]
+ data[_keys.EDGE_FEATURES_KEY] = torch.zeros(edge_index.shape[1], self.idp.orbpair_irreps.dim, dtype=self.dtype, device=self.device)
+ data[_keys.EDGE_FEATURES_KEY] = torch.index_copy(data[_keys.EDGE_FEATURES_KEY], 0, active_edges, self.out_edge(features))
+
+ return data
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = o3.Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+@compile_mode("script")
+class MakeWeightedChannels(torch.nn.Module):
+ weight_numel: int
+ multiplicity_out: Union[int, list]
+ _num_irreps: int
+
+ def __init__(
+ self,
+ irreps_in: o3.Irreps,
+ multiplicity_out: Union[int, list],
+ pad_to_alignment: int = 1,
+ ):
+ super().__init__()
+ assert all(mul == 1 for mul, _ in irreps_in)
+ assert multiplicity_out >= 1
+ # Each edgewise output multiplicity is a per-irrep weighted sum over the input
+ # So we need to apply the weight for the ith irrep to all DOF in that irrep
+ w_index = []
+ idx = 0
+ self._num_irreps = 0
+ for (mul, ir) in irreps_in:
+ w_index += sum(([ix] * ir.dim for ix in range(idx, idx + mul)), [])
+ idx += mul
+ self._num_irreps += mul
+ # w_index = sum(([i] * ir.dim for i, (mul, ir) in enumerate(irreps_in)), [])
+ # pad to padded length
+ n_pad = (
+ int(ceil(irreps_in.dim / pad_to_alignment)) * pad_to_alignment
+ - irreps_in.dim
+ )
+ # use the last weight, what we use doesn't matter much
+ w_index += [w_index[-1]] * n_pad
+ self.register_buffer("_w_index", torch.as_tensor(w_index, dtype=torch.long))
+ # there is
+ self.multiplicity_out = multiplicity_out
+ self.weight_numel = self._num_irreps * multiplicity_out
+
+ def forward(self, edge_attr, weights):
+ # weights are [z, u, num_i]
+ # edge_attr are [z, i]
+ # i runs over all irreps, which is why the weights need
+ # to be indexed in order to go from [num_i] to [i]
+ return torch.einsum(
+ "zi,zui->zui",
+ edge_attr,
+ weights.view(
+ -1,
+ self.multiplicity_out,
+ self._num_irreps,
+ )[:, :, self._w_index],
+ )
+
+@torch.jit.script
+def ShiftedSoftPlus(x: torch.Tensor):
+ return torch.nn.functional.softplus(x) - math.log(2.0)
+
+class ScalarMLPFunction(CodeGenMixin, torch.nn.Module):
+ """Module implementing an MLP according to provided options."""
+
+ in_features: int
+ out_features: int
+
+ def __init__(
+ self,
+ mlp_input_dimension: Optional[int],
+ mlp_latent_dimensions: List[int],
+ mlp_output_dimension: Optional[int],
+ mlp_nonlinearity: Optional[str] = "silu",
+ mlp_initialization: str = "normal",
+ mlp_dropout_p: float = 0.0,
+ mlp_batchnorm: bool = False,
+ ):
+ super().__init__()
+ nonlinearity = {
+ None: None,
+ "silu": torch.nn.functional.silu,
+ "ssp": ShiftedSoftPlus,
+ }[mlp_nonlinearity]
+ if nonlinearity is not None:
+ nonlin_const = normalize2mom(nonlinearity).cst
+ else:
+ nonlin_const = 1.0
+
+ dimensions = (
+ ([mlp_input_dimension] if mlp_input_dimension is not None else [])
+ + mlp_latent_dimensions
+ + ([mlp_output_dimension] if mlp_output_dimension is not None else [])
+ )
+ assert len(dimensions) >= 2 # Must have input and output dim
+ num_layers = len(dimensions) - 1
+
+ self.in_features = dimensions[0]
+ self.out_features = dimensions[-1]
+
+ # Code
+ params = {}
+ graph = fx.Graph()
+ tracer = fx.proxy.GraphAppendingTracer(graph)
+
+ def Proxy(n):
+ return fx.Proxy(n, tracer=tracer)
+
+ features = Proxy(graph.placeholder("x"))
+ norm_from_last: float = 1.0
+
+ base = torch.nn.Module()
+
+ for layer, (h_in, h_out) in enumerate(zip(dimensions, dimensions[1:])):
+ # do dropout
+ if mlp_dropout_p > 0:
+ # only dropout if it will do something
+ # dropout before linear projection- https://stats.stackexchange.com/a/245137
+ features = Proxy(graph.call_module("_dropout", (features.node,)))
+
+ # make weights
+ w = torch.empty(h_in, h_out)
+
+ if mlp_initialization == "normal":
+ w.normal_()
+ elif mlp_initialization == "uniform":
+ # these values give < x^2 > = 1
+ w.uniform_(-math.sqrt(3), math.sqrt(3))
+ elif mlp_initialization == "orthogonal":
+ # this rescaling gives < x^2 > = 1
+ torch.nn.init.orthogonal_(w, gain=math.sqrt(max(w.shape)))
+ else:
+ raise NotImplementedError(
+ f"Invalid mlp_initialization {mlp_initialization}"
+ )
+
+ # generate code
+ params[f"_weight_{layer}"] = w
+ w = Proxy(graph.get_attr(f"_weight_{layer}"))
+ w = w * (
+ norm_from_last / math.sqrt(float(h_in))
+ ) # include any nonlinearity normalization from previous layers
+ features = torch.matmul(features, w)
+
+ if mlp_batchnorm:
+ # if we call batchnorm, do it after the nonlinearity
+ features = Proxy(graph.call_module(f"_bn_{layer}", (features.node,)))
+ setattr(base, f"_bn_{layer}", torch.nn.BatchNorm1d(h_out))
+
+ # generate nonlinearity code
+ if nonlinearity is not None and layer < num_layers - 1:
+ features = nonlinearity(features)
+ # add the normalization const in next layer
+ norm_from_last = nonlin_const
+
+ graph.output(features.node)
+
+ for pname, p in params.items():
+ setattr(base, pname, torch.nn.Parameter(p))
+
+ if mlp_dropout_p > 0:
+ # with normal dropout everything blows up
+ base._dropout = torch.nn.AlphaDropout(p=mlp_dropout_p)
+
+ self._codegen_register({"_forward": fx.GraphModule(base, graph)})
+
+ def forward(self, x):
+ return self._forward(x)
+
+class InitLayer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ idp,
+ num_types: int,
+ n_radial_basis: int,
+ r_max: float,
+ irreps_sh: o3.Irreps=None,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ two_body_latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ device: Union[str, torch.device] = torch.device("cpu"),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(InitLayer, self).__init__()
+ SCALAR = o3.Irrep("0e")
+ self.num_types = num_types
+ if isinstance(r_max, float) or isinstance(r_max, int):
+ self.r_max = torch.tensor(r_max, device=device, dtype=dtype)
+ self.r_max_dict = None
+ elif isinstance(r_max, dict):
+ c_set = set(list(r_max.values()))
+ self.r_max = torch.tensor(max(list(r_max.values())), device=device, dtype=dtype)
+ if len(r_max) == 1 or len(c_set) == 1:
+ self.r_max_dict = None
+ else:
+ self.r_max_dict = {}
+ for k,v in r_max.items():
+ self.r_max_dict[k] = torch.tensor(v, device=device, dtype=dtype)
+ else:
+ raise TypeError("r_max should be either float, int or dict")
+
+ self.idp = idp
+ self.two_body_latent_kwargs = two_body_latent_kwargs
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = PolynomialCutoff_p
+ self.cutoff_type = cutoff_type
+ self.device = device
+ self.dtype = dtype
+ self.irreps_out = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+ # env_embed_irreps = o3.Irreps([(1, ir) for _, ir in irreps_sh])
+ assert (
+ irreps_sh[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+
+ # Node invariants for center and neighbor (chemistry)
+ # Plus edge invariants for the edge (radius).
+ self.two_body_latent = ScalarMLPFunction(
+ mlp_input_dimension=(2 * num_types + n_radial_basis),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=self.irreps_out,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element", # if path normalization is element and input irreps has 1 mul, it should not have effect !
+ )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # instance=False,
+ # normalization="component",
+ # )
+
+ self.env_embed_mlp = ScalarMLPFunction(
+ mlp_input_dimension=self.two_body_latent.out_features,
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ **env_embed_kwargs,
+ )
+
+ self.bessel = BesselBasis(r_max=self.r_max, num_basis=n_radial_basis, trainable=True)
+
+
+
+ def forward(self, edge_index, bond_type, edge_sh, edge_length, node_one_hot):
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ edge_invariants = self.bessel(edge_length)
+ node_invariants = node_one_hot
+
+ # Vectorized precompute per layer cutoffs
+ if self.r_max_dict is None:
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs = cosine_cutoff(
+ edge_length,
+ self.r_max.reshape(-1),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs = polynomial_cutoff(
+ edge_length, self.r_max.reshape(-1), p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+ else:
+ cutoff_coeffs = torch.zeros(edge_index.shape[1], dtype=self.dtype, device=self.device)
+
+ for bond, ty in self.idp.bond_to_type.items():
+ mask = bond_type == ty
+ index = mask.nonzero().squeeze(-1)
+
+ if mask.any():
+ iatom, jatom = bond.split("-")
+ if self.cutoff_type == "cosine":
+ c_coeff = cosine_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+ elif self.cutoff_type == "polynomial":
+ c_coeff = polynomial_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ cutoff_coeffs = torch.index_copy(cutoff_coeffs, 0, index, c_coeff)
+
+ # Determine which edges are still in play
+ prev_mask = cutoff_coeffs > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ latents = torch.zeros(
+ (edge_sh.shape[0], self.two_body_latent.out_features),
+ dtype=edge_sh.dtype,
+ device=edge_sh.device,
+ )
+
+ new_latents = self.two_body_latent(torch.cat([
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ], dim=-1)[prev_mask])
+
+ # Apply cutoff, which propagates through to everything else
+ latents = torch.index_copy(
+ latents, 0, active_edges,
+ cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ )
+ weights = self.env_embed_mlp(new_latents)
+
+ # embed initial edge
+ features = self._env_weighter(
+ edge_sh[prev_mask], weights
+ ) # features is edge_attr
+ # features = self.bn(features)
+
+ return latents, features, cutoff_coeffs, active_edges # the radial embedding x and the sperical hidden V
+
+class Layer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ num_types: int,
+ avg_num_neighbors: Optional[float] = None,
+ irreps_sh: o3.Irreps=None,
+ irreps_in: o3.Irreps=None,
+ irreps_out: o3.Irreps=None,
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_in: int=1024,
+ latent_resnet: bool = True,
+ last_layer: bool = False,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+ super().__init__()
+
+ assert latent_in == latent_kwargs["mlp_latent_dimensions"][-1]
+
+ SCALAR = o3.Irrep("0e")
+ self.latent_resnet = latent_resnet
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.irreps_in = irreps_in
+ self.irreps_out = irreps_out
+ self.last_layer = last_layer
+ self.dtype = dtype
+ self.device = device
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor(avg_num_neighbors).rsqrt(),
+ )
+
+ latent = functools.partial(ScalarMLPFunction, **latent_kwargs)
+
+ self.latents = None
+ self.env_embed_mlps = None
+ self.tps = None
+ self.linears = None
+ self.env_linears = None
+
+ # Prune impossible paths
+ self.irreps_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in self.irreps_out
+ if tp_path_exists(irreps_sh, irreps_in, ir)
+ ]
+ )
+
+ mul_irreps_sh = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=mul_irreps_sh,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element",
+ )
+
+ if last_layer:
+ self._node_weighter = E3ElementLinear(
+ irreps_in=irreps_out,
+ dtype=dtype,
+ device=device,
+ )
+
+ self._edge_weighter = E3ElementLinear(
+ irreps_in=irreps_out,
+ dtype=dtype,
+ device=device,
+ )
+
+ # == Remove unneeded paths ==
+ #TODO: add the remove unseen paths
+
+ if self.linear_after_env_embed:
+ self.env_linears = Linear(
+ mul_irreps_sh,
+ mul_irreps_sh,
+ shared_weights=True,
+ internal_weights=True,
+ )
+
+ else:
+ self.env_linears = torch.nn.Identity()
+
+ # # Make TP
+ # tmp_i_out: int = 0
+ # instr = []
+ # n_scalar_outs: int = 0
+ # n_scalar_mul = []
+ # full_out_irreps = []
+ # for i_out, (mul_out, ir_out) in enumerate(self.irreps_out):
+ # for i_1, (mul1, ir_1) in enumerate(self.irreps_in): # what if feature_irreps_in has mul?
+ # for i_2, (mul2, ir_2) in enumerate(self._env_weighter.irreps_out):
+ # if ir_out in ir_1 * ir_2:
+ # if ir_out == SCALAR:
+ # n_scalar_outs += 1
+ # n_scalar_mul.append(mul2)
+ # # assert mul_out == mul1 == mul2
+ # instr.append((i_1, i_2, tmp_i_out, 'uvv', True))
+ # full_out_irreps.append((mul2, ir_out))
+ # assert full_out_irreps[-1][0] == mul2
+ # tmp_i_out += 1
+ # full_out_irreps = o3.Irreps(full_out_irreps)
+ # assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ # self.n_scalar_mul = sum(n_scalar_mul)
+
+ self.lin_pre = Linear(
+ irreps_in=self.irreps_in,
+ irreps_out=self.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.tp = TensorProduct(
+ # irreps_in1=o3.Irreps(
+ # [(mul, ir) for mul, ir in self.irreps_in]
+ # ),
+ # irreps_in2=o3.Irreps(
+ # [(mul, ir) for mul, ir in self._env_weighter.irreps_out]
+ # ),
+ # irreps_out=o3.Irreps(
+ # [(mul, ir) for mul, ir in full_out_irreps]
+ # ),
+ # irrep_normalization="component",
+ # instructions=instr,
+ # shared_weights=True,
+ # internal_weights=True,
+ # )
+ # build activation
+
+ irreps_scalar = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l == 0]).simplify()
+ irreps_gated = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l > 0]).simplify()
+
+
+ irreps_gates = o3.Irreps([(mul, (0,1)) for mul, _ in irreps_gated]).simplify()
+ act={1: torch.nn.functional.silu, -1: torch.tanh}
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+
+ self.activation = Gate(
+ irreps_scalar, [act[ir.p] for _, ir in irreps_scalar], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ self.tp = SeparateWeightTensorProduct(
+ irreps_in1=self.irreps_in,
+ irreps_in2=self._env_weighter.irreps_out,
+ irreps_out=self.activation.irreps_in,
+ )
+
+ if self.last_layer:
+ self.tp_out = SeparateWeightTensorProduct(
+ irreps_in1=self.irreps_out+self._env_weighter.irreps_out+self._env_weighter.irreps_out,
+ irreps_in2=irreps_sh,
+ irreps_out=self.irreps_out,
+ )
+
+ # self.sc = FullyConnectedTensorProduct(
+ # irreps_in,
+ # o3.Irreps(str(2*num_types)+"x0e"),
+ # self.irreps_out,
+ # shared_weights=True,
+ # internal_weights=True
+ # )
+
+ self.lin_post = Linear(
+ self.activation.irreps_out,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.bn = TypeNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # num_type=num_types*num_types,
+ # normalization="component",
+ # )
+
+ self.bn = BatchNorm(
+ irreps=self.irreps_out,
+ affine=True,
+ normalization="component",
+ )
+
+ if latent_resnet:
+ self.linear_res = Linear(
+ self.irreps_in,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # we extract the scalars from the first irrep of the tp
+ # assert full_out_irreps[0].ir == SCALAR
+ # self.linears = Linear(
+ # irreps_in=full_out_irreps,
+ # irreps_out=self.activation.irreps_in,
+ # shared_weights=True,
+ # internal_weights=True,
+ # biases=True,
+ # )
+
+ # the embedded latent invariants from the previous layer(s)
+ # and the invariants extracted from the last layer's TP:
+ # we need to make sure all scalars in tp.irreps_out all contains in the first irreps
+ all_tp_scalar = o3.Irreps([(mul, ir) for mul, ir in self.tp.irreps_out if ir.l == 0]).simplify()
+ assert all_tp_scalar.dim == self.tp.irreps_out[0].dim
+ self.latents = latent(
+ mlp_input_dimension=latent_in+self.tp.irreps_out[0].dim,
+ mlp_output_dimension=None,
+ )
+
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ )
+
+ if last_layer:
+ self.node_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._node_weighter.weight_numel,
+ )
+
+ self.edge_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._edge_weighter.weight_numel,
+ )
+
+ # self.node_bn = TypeNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # num_type=num_types,
+ # normalization="component",
+ # )
+
+ self.node_bn = BatchNorm(
+ irreps=self.irreps_out,
+ affine=True,
+ normalization="component",
+ )
+
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(1)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios > 0.0
+ assert latent_resnet_update_ratios < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ def forward(self, edge_index, edge_sh, atom_type, bond_type, latents, features, cutoff_coeffs, active_edges, batch):
+ # update V
+ # update X
+ # edge_index: [2, num_edges]
+ # irreps_sh: [num_edges, irreps_sh]
+ # latents: [num_edges, latent_in]
+ # fetures: [num_active_edges, in_irreps]
+ # cutoff_coeffs: [num_edges]
+ # active_edges: [num_active_edges]
+
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ prev_mask = cutoff_coeffs > 0
+
+ # sc_features = self.sc(features, node_one_hot[edge_index].transpose(0,1).flatten(1,2)[active_edges])
+ # update V
+ weights = self.env_embed_mlps(latents[active_edges])
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_sh[active_edges], weights),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ # currently, we have a sum over neighbors of constant number for each layer,
+ # the env_sum_normalization can be a scalar or list
+ # the different cutoff can be added in the future
+
+ if self.env_sum_normalizations.ndim < 1:
+ norm_const = self.env_sum_normalizations
+ else:
+ norm_const = self.env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = self.env_linears(local_env_per_edge)
+
+ # local_env_per_edge = torch.cat([local_env_per_edge[edge_center[active_edges]], local_env_per_edge[edge_neighbor[active_edges]]], dim=-1)
+ # local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ new_features = self.tp(self.lin_pre(features), local_env_per_edge[edge_center[active_edges]]) # full_out_irreps
+
+ scalars = new_features[:, :self.tp.irreps_out[0].dim]
+ new_features = self.activation(new_features)
+ # # do the linear
+ # new_features = self.linears(new_features)
+
+
+ # features has shape [N_edge, full_feature_out.dim]
+ # we know scalars are first
+ assert len(scalars.shape) == 2
+
+ new_features = self.lin_post(new_features)
+
+ # new_features = self.bn(new_features, bond_type[active_edges])
+ # new_features = new_features - scatter_mean(new_features, batch[edge_center[active_edges]], dim=0, dim_size=batch.max()+1)[batch[edge_center[active_edges]]]
+ new_features = self.bn(new_features)
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ features = coefficient_new * new_features + coefficient_old * self.linear_res(features)
+ else:
+ features = new_features
+
+ # whether it is the last layer
+
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ new_latents = self.latents(torch.cat(latent_inputs_to_cat, dim=-1))
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ if self.last_layer:
+ node_weights = self.node_embed_mlps(latents[active_edges])
+
+ node_features = scatter(
+ self._node_weighter(
+ features,
+ node_weights,
+ ),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ node_features = node_features * norm_const
+
+ # node_features = self.node_bn(node_features, atom_type)
+ node_features = self.node_bn(node_features)
+
+ edge_weights = self.edge_embed_mlps(latents[active_edges])
+
+ # the features's inclusion of the radial weight here is the only place
+ # where features are weighted according to the radial distance
+ features = self.tp_out(
+ torch.cat(
+ [
+ features,
+ local_env_per_edge[edge_center[active_edges]],
+ local_env_per_edge[edge_neighbor[active_edges]],
+ ], dim=-1
+ ),
+ edge_sh[active_edges],
+ )
+
+ features = self._edge_weighter(
+ features,
+ edge_weights,
+ )
+
+ return node_features, features, cutoff_coeffs, active_edges
+ else:
+ return latents, features, cutoff_coeffs, active_edges
+
\ No newline at end of file
diff --git a/dptb/nn/embedding/e3baseline_nonlocal.py b/dptb/nn/embedding/e3baseline_nonlocal.py
new file mode 100644
index 00000000..636859a0
--- /dev/null
+++ b/dptb/nn/embedding/e3baseline_nonlocal.py
@@ -0,0 +1,934 @@
+from typing import Optional, List, Union, Dict
+import math
+import functools
+import warnings
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from e3nn import o3
+from e3nn.nn import Gate, Activation
+from e3nn.nn._batchnorm import BatchNorm
+from e3nn.o3 import TensorProduct, Linear, SphericalHarmonics, FullyConnectedTensorProduct
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..radial_basis import BesselBasis
+from dptb.nn.graph_mixin import GraphModuleMixin
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.nn.embedding.from_deephe3.e3module import SeparateWeightTensorProduct
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+import math
+from dptb.data.transforms import OrbitalMapper
+from ..type_encode.one_hot import OneHotAtomEncoding
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+
+from math import ceil
+
+@Embedding.register("e3baseline_nonlocal")
+class E3BaseLineModelNonLocal(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ # required params
+ n_atom: int=1,
+ n_layers: int=3,
+ n_radial_basis: int=10,
+ r_max: float=5.0,
+ lmax: int=4,
+ irreps_hidden: o3.Irreps=None,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ sh_normalized: bool = True,
+ sh_normalization: str = "component",
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [256, 256, 512],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+
+ super(E3BaseLineModelNonLocal, self).__init__()
+
+ irreps_hidden = o3.Irreps(irreps_hidden)
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_irreps(no_parity=False)
+
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ orbpair_irreps = self.idp.orbpair_irreps.sort()[0].simplify()
+
+ # check if the irreps setting satisfied the requirement of idp
+ irreps_out = []
+ for mul, ir1 in irreps_hidden:
+ for _, ir2 in orbpair_irreps:
+ irreps_out += [o3.Irrep(str(irr)) for irr in ir1*ir2]
+ irreps_out = o3.Irreps(irreps_out).sort()[0].simplify()
+
+ assert all(ir in irreps_out for _, ir in orbpair_irreps), "hidden irreps should at least cover all the reqired irreps in the hamiltonian data {}".format(orbpair_irreps)
+
+ # TODO: check if the tp in first layer can produce the required irreps for hidden states
+
+ self.sh = SphericalHarmonics(
+ irreps_sh, sh_normalized, sh_normalization
+ )
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ self.init_layer = InitLayer(
+ idp=self.idp,
+ num_types=n_atom,
+ n_radial_basis=n_radial_basis,
+ r_max=r_max,
+ irreps_sh=irreps_sh,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ two_body_latent_kwargs=latent_kwargs,
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio=r_start_cos_ratio,
+ PolynomialCutoff_p=PolynomialCutoff_p,
+ cutoff_type=cutoff_type,
+ device=device,
+ dtype=dtype,
+ )
+
+ self.layers = torch.nn.ModuleList()
+ latent_in =latent_kwargs["mlp_latent_dimensions"][-1]
+ # actually, we can derive the least required irreps_in and out from the idp's node and pair irreps
+ for i in range(n_layers):
+ if i == 0:
+ irreps_in = self.init_layer.irreps_out
+ else:
+ irreps_in = irreps_hidden
+
+ if i == n_layers - 1:
+ irreps_out = orbpair_irreps.sort()[0].simplify()
+ else:
+ irreps_out = irreps_hidden
+
+ self.layers.append(Layer(
+ num_types=n_atom,
+ avg_num_neighbors=avg_num_neighbors,
+ irreps_sh=irreps_sh,
+ irreps_in=irreps_in,
+ irreps_out=irreps_out,
+ # general hyperparameters:
+ linear_after_env_embed=linear_after_env_embed,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ latent_kwargs=latent_kwargs,
+ latent_in=latent_in,
+ latent_resnet=latent_resnet,
+ latent_resnet_update_ratios=latent_resnet_update_ratios,
+ latent_resnet_update_ratios_learnable=latent_resnet_update_ratios_learnable,
+ )
+ )
+
+ # initilize output_layer
+ self.out_edge = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ # data = with_env_vectors(data, with_lengths=True)
+ data = with_batch(data)
+
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_sh = self.sh(data[_keys.EDGE_VECTORS_KEY][:,[1,2,0]])
+ edge_length = data[_keys.EDGE_LENGTH_KEY]
+
+
+ data = self.onehot(data)
+ node_one_hot = data[_keys.NODE_ATTRS_KEY]
+ atom_type = data[_keys.ATOM_TYPE_KEY].flatten()
+ bond_type = data[_keys.EDGE_TYPE_KEY].flatten()
+ latents, features, cutoff_coeffs, active_edges = self.init_layer(edge_index, bond_type, edge_sh, edge_length, node_one_hot)
+
+ for layer in self.layers:
+ latents, features, cutoff_coeffs, active_edges = layer(edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges)
+
+ if self.layers[-1].env_sum_normalizations.ndim < 1:
+ norm_const = self.layers[-1].env_sum_normalizations
+ else:
+ norm_const = self.layers[-1].env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ data[_keys.EDGE_FEATURES_KEY] = torch.zeros(edge_index.shape[1], self.idp.orbpair_irreps.dim, dtype=self.dtype, device=self.device)
+ data[_keys.EDGE_FEATURES_KEY] = torch.index_copy(data[_keys.EDGE_FEATURES_KEY], 0, active_edges, self.out_edge(features))
+ node_features = scatter(features, edge_index[0][active_edges], dim=0)
+ data[_keys.NODE_FEATURES_KEY] = self.out_node(node_features * norm_const)
+
+ return data
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = o3.Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+@compile_mode("script")
+class MakeWeightedChannels(torch.nn.Module):
+ weight_numel: int
+ multiplicity_out: Union[int, list]
+ _num_irreps: int
+
+ def __init__(
+ self,
+ irreps_in,
+ multiplicity_out: Union[int, list],
+ pad_to_alignment: int = 1,
+ ):
+ super().__init__()
+ assert all(mul == 1 for mul, _ in irreps_in)
+ assert multiplicity_out >= 1
+ # Each edgewise output multiplicity is a per-irrep weighted sum over the input
+ # So we need to apply the weight for the ith irrep to all DOF in that irrep
+ w_index = []
+ idx = 0
+ self._num_irreps = 0
+ for (mul, ir) in irreps_in:
+ w_index += sum(([ix] * ir.dim for ix in range(idx, idx + mul)), [])
+ idx += mul
+ self._num_irreps += mul
+ # w_index = sum(([i] * ir.dim for i, (mul, ir) in enumerate(irreps_in)), [])
+ # pad to padded length
+ n_pad = (
+ int(ceil(irreps_in.dim / pad_to_alignment)) * pad_to_alignment
+ - irreps_in.dim
+ )
+ # use the last weight, what we use doesn't matter much
+ w_index += [w_index[-1]] * n_pad
+ self.register_buffer("_w_index", torch.as_tensor(w_index, dtype=torch.long))
+ # there is
+ self.multiplicity_out = multiplicity_out
+ self.weight_numel = self._num_irreps * multiplicity_out
+
+ def forward(self, edge_attr, weights):
+ # weights are [z, u, num_i]
+ # edge_attr are [z, i]
+ # i runs over all irreps, which is why the weights need
+ # to be indexed in order to go from [num_i] to [i]
+ return torch.einsum(
+ "zi,zui->zui",
+ edge_attr,
+ weights.view(
+ -1,
+ self.multiplicity_out,
+ self._num_irreps,
+ )[:, :, self._w_index],
+ )
+
+@torch.jit.script
+def ShiftedSoftPlus(x):
+ return torch.nn.functional.softplus(x) - math.log(2.0)
+
+class ScalarMLPFunction(CodeGenMixin, torch.nn.Module):
+ """Module implementing an MLP according to provided options."""
+
+ in_features: int
+ out_features: int
+
+ def __init__(
+ self,
+ mlp_input_dimension: Optional[int],
+ mlp_latent_dimensions: List[int],
+ mlp_output_dimension: Optional[int],
+ mlp_nonlinearity: Optional[str] = "silu",
+ mlp_initialization: str = "normal",
+ mlp_dropout_p: float = 0.0,
+ mlp_batchnorm: bool = False,
+ ):
+ super().__init__()
+ nonlinearity = {
+ None: None,
+ "silu": torch.nn.functional.silu,
+ "ssp": ShiftedSoftPlus,
+ }[mlp_nonlinearity]
+ if nonlinearity is not None:
+ nonlin_const = normalize2mom(nonlinearity).cst
+ else:
+ nonlin_const = 1.0
+
+ dimensions = (
+ ([mlp_input_dimension] if mlp_input_dimension is not None else [])
+ + mlp_latent_dimensions
+ + ([mlp_output_dimension] if mlp_output_dimension is not None else [])
+ )
+ assert len(dimensions) >= 2 # Must have input and output dim
+ num_layers = len(dimensions) - 1
+
+ self.in_features = dimensions[0]
+ self.out_features = dimensions[-1]
+
+ # Code
+ params = {}
+ graph = fx.Graph()
+ tracer = fx.proxy.GraphAppendingTracer(graph)
+
+ def Proxy(n):
+ return fx.Proxy(n, tracer=tracer)
+
+ features = Proxy(graph.placeholder("x"))
+ norm_from_last: float = 1.0
+
+ base = torch.nn.Module()
+
+ for layer, (h_in, h_out) in enumerate(zip(dimensions, dimensions[1:])):
+ # do dropout
+ if mlp_dropout_p > 0:
+ # only dropout if it will do something
+ # dropout before linear projection- https://stats.stackexchange.com/a/245137
+ features = Proxy(graph.call_module("_dropout", (features.node,)))
+
+ # make weights
+ w = torch.empty(h_in, h_out)
+
+ if mlp_initialization == "normal":
+ w.normal_()
+ elif mlp_initialization == "uniform":
+ # these values give < x^2 > = 1
+ w.uniform_(-math.sqrt(3), math.sqrt(3))
+ elif mlp_initialization == "orthogonal":
+ # this rescaling gives < x^2 > = 1
+ torch.nn.init.orthogonal_(w, gain=math.sqrt(max(w.shape)))
+ else:
+ raise NotImplementedError(
+ f"Invalid mlp_initialization {mlp_initialization}"
+ )
+
+ # generate code
+ params[f"_weight_{layer}"] = w
+ w = Proxy(graph.get_attr(f"_weight_{layer}"))
+ w = w * (
+ norm_from_last / math.sqrt(float(h_in))
+ ) # include any nonlinearity normalization from previous layers
+ features = torch.matmul(features, w)
+
+ if mlp_batchnorm:
+ # if we call batchnorm, do it after the nonlinearity
+ features = Proxy(graph.call_module(f"_bn_{layer}", (features.node,)))
+ setattr(base, f"_bn_{layer}", torch.nn.BatchNorm1d(h_out))
+
+ # generate nonlinearity code
+ if nonlinearity is not None and layer < num_layers - 1:
+ features = nonlinearity(features)
+ # add the normalization const in next layer
+ norm_from_last = nonlin_const
+
+ graph.output(features.node)
+
+ for pname, p in params.items():
+ setattr(base, pname, torch.nn.Parameter(p))
+
+ if mlp_dropout_p > 0:
+ # with normal dropout everything blows up
+ base._dropout = torch.nn.AlphaDropout(p=mlp_dropout_p)
+
+ self._codegen_register({"_forward": fx.GraphModule(base, graph)})
+
+ def forward(self, x):
+ return self._forward(x)
+
+class InitLayer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ idp,
+ num_types: int,
+ n_radial_basis: int,
+ r_max: float,
+ irreps_sh: o3.Irreps=None,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ two_body_latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ device: Union[str, torch.device] = torch.device("cpu"),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(InitLayer, self).__init__()
+ SCALAR = o3.Irrep("0e")
+ self.num_types = num_types
+ if isinstance(r_max, float) or isinstance(r_max, int):
+ self.r_max = torch.tensor(r_max, device=device, dtype=dtype)
+ self.r_max_dict = None
+ elif isinstance(r_max, dict):
+ c_set = set(list(r_max.values()))
+ self.r_max = torch.tensor(max(list(r_max.values())), device=device, dtype=dtype)
+ if len(r_max) == 1 or len(c_set) == 1:
+ self.r_max_dict = None
+ else:
+ self.r_max_dict = {}
+ for k,v in r_max.items():
+ self.r_max_dict[k] = torch.tensor(v, device=device, dtype=dtype)
+ else:
+ raise TypeError("r_max should be either float, int or dict")
+
+ self.idp = idp
+ self.two_body_latent_kwargs = two_body_latent_kwargs
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = PolynomialCutoff_p
+ self.cutoff_type = cutoff_type
+ self.device = device
+ self.dtype = dtype
+ self.irreps_out = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+ # env_embed_irreps = o3.Irreps([(1, ir) for _, ir in irreps_sh])
+ assert (
+ irreps_sh[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+
+ # Node invariants for center and neighbor (chemistry)
+ # Plus edge invariants for the edge (radius).
+ self.two_body_latent = ScalarMLPFunction(
+ mlp_input_dimension=(2 * num_types + n_radial_basis),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=self.irreps_out,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element", # if path normalization is element and input irreps has 1 mul, it should not have effect !
+ )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # instance=False,
+ # normalization="component",
+ # )
+
+ self.env_embed_mlp = ScalarMLPFunction(
+ mlp_input_dimension=self.two_body_latent.out_features,
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ **env_embed_kwargs,
+ )
+
+ self.bessel = BesselBasis(r_max=self.r_max, num_basis=n_radial_basis, trainable=True)
+
+
+
+ def forward(self, edge_index, bond_type, edge_sh, edge_length, node_one_hot):
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ edge_invariants = self.bessel(edge_length)
+ node_invariants = node_one_hot
+
+ # Vectorized precompute per layer cutoffs
+ if self.r_max_dict is None:
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs = cosine_cutoff(
+ edge_length,
+ self.r_max.reshape(-1),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs = polynomial_cutoff(
+ edge_length, self.r_max.reshape(-1), p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+ else:
+ cutoff_coeffs = torch.zeros(edge_index.shape[1], dtype=self.dtype, device=self.device)
+
+ for bond, ty in self.idp.bond_to_type.items():
+ mask = bond_type == ty
+ index = mask.nonzero().squeeze(-1)
+
+ if mask.any():
+ iatom, jatom = bond.split("-")
+ if self.cutoff_type == "cosine":
+ c_coeff = cosine_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+ elif self.cutoff_type == "polynomial":
+ c_coeff = polynomial_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ cutoff_coeffs = torch.index_copy(cutoff_coeffs, 0, index, c_coeff)
+
+ # Determine which edges are still in play
+ prev_mask = cutoff_coeffs > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ latents = torch.zeros(
+ (edge_sh.shape[0], self.two_body_latent.out_features),
+ dtype=edge_sh.dtype,
+ device=edge_sh.device,
+ )
+
+ new_latents = self.two_body_latent(torch.cat([
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ], dim=-1)[prev_mask])
+
+ # Apply cutoff, which propagates through to everything else
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+ weights = self.env_embed_mlp(latents[active_edges])
+
+ # embed initial edge
+ features = self._env_weighter(
+ edge_sh[prev_mask], weights
+ ) # features is edge_attr
+ # features = self.bn(features)
+
+ return latents, features, cutoff_coeffs, active_edges # the radial embedding x and the sperical hidden V
+
+class Layer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ num_types: int,
+ avg_num_neighbors: Optional[float] = None,
+ irreps_sh: o3.Irreps=None,
+ irreps_in: o3.Irreps=None,
+ irreps_out: o3.Irreps=None,
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_in: int=1024,
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ ):
+ super().__init__()
+ SCALAR = o3.Irrep("0e")
+ self.latent_resnet = latent_resnet
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.irreps_in = irreps_in
+ self.irreps_out = irreps_out
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor(avg_num_neighbors).rsqrt(),
+ )
+
+ latent = functools.partial(ScalarMLPFunction, **latent_kwargs)
+
+ self.latents = None
+ self.env_embed_mlps = None
+ self.tps = None
+ self.linears = None
+ self.env_linears = None
+
+ # Prune impossible paths
+ self.irreps_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in self.irreps_out
+ if tp_path_exists(irreps_sh, irreps_in, ir)
+ ]
+ )
+
+ mul_irreps_sh = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=mul_irreps_sh,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element",
+ )
+
+ # == Remove unneeded paths ==
+ #TODO: add the remove unseen paths
+
+ if self.linear_after_env_embed:
+ self.env_linears = Linear(
+ mul_irreps_sh,
+ mul_irreps_sh,
+ shared_weights=True,
+ internal_weights=True,
+ )
+ else:
+ self.env_linears = torch.nn.Identity()
+
+ # # Make TP
+ # tmp_i_out: int = 0
+ # instr = []
+ # n_scalar_outs: int = 0
+ # n_scalar_mul = []
+ # full_out_irreps = []
+ # for i_out, (mul_out, ir_out) in enumerate(self.irreps_out):
+ # for i_1, (mul1, ir_1) in enumerate(self.irreps_in): # what if feature_irreps_in has mul?
+ # for i_2, (mul2, ir_2) in enumerate(self._env_weighter.irreps_out):
+ # if ir_out in ir_1 * ir_2:
+ # if ir_out == SCALAR:
+ # n_scalar_outs += 1
+ # n_scalar_mul.append(mul2)
+ # # assert mul_out == mul1 == mul2
+ # instr.append((i_1, i_2, tmp_i_out, 'uvv', True))
+ # full_out_irreps.append((mul2, ir_out))
+ # assert full_out_irreps[-1][0] == mul2
+ # tmp_i_out += 1
+ # full_out_irreps = o3.Irreps(full_out_irreps)
+ # assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ # self.n_scalar_mul = sum(n_scalar_mul)
+
+ self.lin_pre = Linear(
+ irreps_in=self.irreps_in,
+ irreps_out=self.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.tp = TensorProduct(
+ # irreps_in1=o3.Irreps(
+ # [(mul, ir) for mul, ir in self.irreps_in]
+ # ),
+ # irreps_in2=o3.Irreps(
+ # [(mul, ir) for mul, ir in self._env_weighter.irreps_out]
+ # ),
+ # irreps_out=o3.Irreps(
+ # [(mul, ir) for mul, ir in full_out_irreps]
+ # ),
+ # irrep_normalization="component",
+ # instructions=instr,
+ # shared_weights=True,
+ # internal_weights=True,
+ # )
+ # build activation
+
+ irreps_scalar = o3.Irreps(str(self.irreps_out[0]))
+ irreps_gated = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l > 0]).simplify()
+ irreps_gates = o3.Irreps([(mul, (0,1)) for mul, _ in irreps_gated]).simplify()
+ act={1: torch.nn.functional.silu, -1: torch.tanh}
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+
+ self.activation = Gate(
+ irreps_scalar, [act[ir.p] for _, ir in irreps_scalar], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ self.tp = SeparateWeightTensorProduct(
+ irreps_in1=self._env_weighter.irreps_out+self.irreps_in+self._env_weighter.irreps_out,
+ irreps_in2=irreps_sh,
+ irreps_out=self.activation.irreps_in,
+ )
+
+ # self.sc = FullyConnectedTensorProduct(
+ # irreps_in,
+ # o3.Irreps(str(2*num_types)+"x0e"),
+ # self.irreps_out,
+ # shared_weights=True,
+ # internal_weights=True
+ # )
+
+ self.lin_post = Linear(
+ self.irreps_out,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ self.bn = BatchNorm(
+ irreps=self.irreps_out,
+ affine=True,
+ instance=False,
+ normalization="component",
+ )
+
+ self.linear_res = Linear(
+ self.irreps_in,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # we extract the scalars from the first irrep of the tp
+ # assert full_out_irreps[0].ir == SCALAR
+ # self.linears = Linear(
+ # irreps_in=full_out_irreps,
+ # irreps_out=self.activation.irreps_in,
+ # shared_weights=True,
+ # internal_weights=True,
+ # biases=True,
+ # )
+
+ # the embedded latent invariants from the previous layer(s)
+ # and the invariants extracted from the last layer's TP:
+ self.latents = latent(
+ mlp_input_dimension=latent_in+self.irreps_out[0].dim,
+ mlp_output_dimension=None,
+ )
+
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ )
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(1)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios > 0.0
+ assert latent_resnet_update_ratios < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ def forward(self, edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges):
+ # update V
+ # update X
+ # edge_index: [2, num_edges]
+ # irreps_sh: [num_edges, irreps_sh]
+ # latents: [num_edges, latent_in]
+ # fetures: [num_active_edges, in_irreps]
+ # cutoff_coeffs: [num_edges]
+ # active_edges: [num_active_edges]
+
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ prev_mask = cutoff_coeffs > 0
+
+ # sc_features = self.sc(features, node_one_hot[edge_index].transpose(0,1).flatten(1,2)[active_edges])
+ # update V
+ weights = self.env_embed_mlps(latents[active_edges])
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_sh[active_edges], weights),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ # currently, we have a sum over neighbors of constant number for each layer,
+ # the env_sum_normalization can be a scalar or list
+ # the different cutoff can be added in the future
+
+ if self.env_sum_normalizations.ndim < 1:
+ norm_const = self.env_sum_normalizations
+ else:
+ norm_const = self.env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = self.env_linears(local_env_per_edge)
+
+ # local_env_per_edge = torch.cat([local_env_per_edge[edge_center[active_edges]], local_env_per_edge[edge_neighbor[active_edges]]], dim=-1)
+ # local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ new_features = self.tp(
+ torch.cat(
+ [
+ local_env_per_edge[edge_center[active_edges]],
+ self.lin_pre(features),
+ local_env_per_edge[edge_neighbor[active_edges]]
+ ], dim=-1),
+ edge_sh[active_edges]) # full_out_irreps
+
+ new_features = self.activation(new_features)
+ # # do the linear
+ # new_features = self.linears(new_features)
+
+
+ # features has shape [N_edge, full_feature_out.dim]
+ # we know scalars are first
+ scalars = new_features[:, :self.irreps_out[0].dim]
+ assert len(scalars.shape) == 2
+
+ new_features = self.lin_post(new_features)
+
+ new_features = self.bn(new_features)
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ features = coefficient_new * new_features + coefficient_old * self.linear_res(features)
+ else:
+ features = new_features
+
+ # update X
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ new_latents = self.latents(torch.cat(latent_inputs_to_cat, dim=-1))
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ return latents, features, cutoff_coeffs, active_edges
+
\ No newline at end of file
diff --git a/dptb/nn/embedding/e3baseline_nonlocal_wnode.py b/dptb/nn/embedding/e3baseline_nonlocal_wnode.py
new file mode 100644
index 00000000..ab45b77a
--- /dev/null
+++ b/dptb/nn/embedding/e3baseline_nonlocal_wnode.py
@@ -0,0 +1,934 @@
+from typing import Optional, List, Union, Dict
+import math
+import functools
+import warnings
+
+import torch
+from torch_runstats.scatter import scatter
+
+from torch import fx
+from e3nn.util.codegen import CodeGenMixin
+from e3nn import o3
+from e3nn.nn import Gate, Activation
+from e3nn.nn._batchnorm import BatchNorm
+from e3nn.o3 import TensorProduct, Linear, SphericalHarmonics, FullyConnectedTensorProduct
+from e3nn.math import normalize2mom
+from e3nn.util.jit import compile_mode
+
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..radial_basis import BesselBasis
+from dptb.nn.graph_mixin import GraphModuleMixin
+from dptb.nn.embedding.from_deephe3.deephe3 import tp_path_exists
+from dptb.nn.embedding.from_deephe3.e3module import SeparateWeightTensorProduct
+from dptb.data import _keys
+from dptb.nn.cutoff import cosine_cutoff, polynomial_cutoff
+import math
+from dptb.data.transforms import OrbitalMapper
+from ..type_encode.one_hot import OneHotAtomEncoding
+from dptb.data.AtomicDataDict import with_edge_vectors, with_env_vectors, with_batch
+
+from math import ceil
+
+@Embedding.register("e3baseline_nonlocal_wnode")
+class E3BaseLineModelNonLocalWNODE(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ # required params
+ n_atom: int=1,
+ n_layers: int=3,
+ n_radial_basis: int=10,
+ r_max: float=5.0,
+ lmax: int=4,
+ irreps_hidden: o3.Irreps=None,
+ avg_num_neighbors: Optional[float] = None,
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ sh_normalized: bool = True,
+ sh_normalization: str = "component",
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [256, 256, 512],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+
+ super(E3BaseLineModelNonLocalWNODE, self).__init__()
+
+ irreps_hidden = o3.Irreps(irreps_hidden)
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_irreps(no_parity=False)
+
+ irreps_sh=o3.Irreps([(1, (i, (-1) ** i)) for i in range(lmax + 1)])
+ orbpair_irreps = self.idp.orbpair_irreps.sort()[0].simplify()
+
+ # check if the irreps setting satisfied the requirement of idp
+ irreps_out = []
+ for mul, ir1 in irreps_hidden:
+ for _, ir2 in orbpair_irreps:
+ irreps_out += [o3.Irrep(str(irr)) for irr in ir1*ir2]
+ irreps_out = o3.Irreps(irreps_out).sort()[0].simplify()
+
+ assert all(ir in irreps_out for _, ir in orbpair_irreps), "hidden irreps should at least cover all the reqired irreps in the hamiltonian data {}".format(orbpair_irreps)
+
+ # TODO: check if the tp in first layer can produce the required irreps for hidden states
+
+ self.sh = SphericalHarmonics(
+ irreps_sh, sh_normalized, sh_normalization
+ )
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+
+ self.init_layer = InitLayer(
+ idp=self.idp,
+ num_types=n_atom,
+ n_radial_basis=n_radial_basis,
+ r_max=r_max,
+ irreps_sh=irreps_sh,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ two_body_latent_kwargs=latent_kwargs,
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio=r_start_cos_ratio,
+ PolynomialCutoff_p=PolynomialCutoff_p,
+ cutoff_type=cutoff_type,
+ device=device,
+ dtype=dtype,
+ )
+
+ self.layers = torch.nn.ModuleList()
+ latent_in =latent_kwargs["mlp_latent_dimensions"][-1]
+ # actually, we can derive the least required irreps_in and out from the idp's node and pair irreps
+ for i in range(n_layers):
+ if i == 0:
+ irreps_in = self.init_layer.irreps_out
+ else:
+ irreps_in = irreps_hidden
+
+ if i == n_layers - 1:
+ irreps_out = orbpair_irreps.sort()[0].simplify()
+ else:
+ irreps_out = irreps_hidden
+
+ self.layers.append(Layer(
+ num_types=n_atom,
+ avg_num_neighbors=avg_num_neighbors,
+ irreps_sh=irreps_sh,
+ irreps_in=irreps_in,
+ irreps_out=irreps_out,
+ # general hyperparameters:
+ linear_after_env_embed=linear_after_env_embed,
+ env_embed_multiplicity=env_embed_multiplicity,
+ # MLP parameters:
+ latent_kwargs=latent_kwargs,
+ latent_in=latent_in,
+ latent_resnet=latent_resnet,
+ latent_resnet_update_ratios=latent_resnet_update_ratios,
+ latent_resnet_update_ratios_learnable=latent_resnet_update_ratios_learnable,
+ )
+ )
+
+ # initilize output_layer
+ self.out_edge = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+ self.out_node = Linear(self.layers[-1].irreps_out, self.idp.orbpair_irreps, shared_weights=True, internal_weights=True, biases=True)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = with_edge_vectors(data, with_lengths=True)
+ # data = with_env_vectors(data, with_lengths=True)
+ data = with_batch(data)
+
+ edge_index = data[_keys.EDGE_INDEX_KEY]
+ edge_sh = self.sh(data[_keys.EDGE_VECTORS_KEY][:,[1,2,0]])
+ edge_length = data[_keys.EDGE_LENGTH_KEY]
+
+
+ data = self.onehot(data)
+ node_one_hot = data[_keys.NODE_ATTRS_KEY]
+ atom_type = data[_keys.ATOM_TYPE_KEY].flatten()
+ bond_type = data[_keys.EDGE_TYPE_KEY].flatten()
+ latents, features, cutoff_coeffs, active_edges = self.init_layer(edge_index, bond_type, edge_sh, edge_length, node_one_hot)
+
+ for layer in self.layers:
+ latents, features, cutoff_coeffs, active_edges = layer(edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges)
+
+ if self.layers[-1].env_sum_normalizations.ndim < 1:
+ norm_const = self.layers[-1].env_sum_normalizations
+ else:
+ norm_const = self.layers[-1].env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ data[_keys.EDGE_FEATURES_KEY] = torch.zeros(edge_index.shape[1], self.idp.orbpair_irreps.dim, dtype=self.dtype, device=self.device)
+ data[_keys.EDGE_FEATURES_KEY] = torch.index_copy(data[_keys.EDGE_FEATURES_KEY], 0, active_edges, self.out_edge(features))
+ node_features = scatter(features, edge_index[0][active_edges], dim=0)
+ data[_keys.NODE_FEATURES_KEY] = self.out_node(node_features * norm_const)
+
+ return data
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = o3.Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = o3.Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+@compile_mode("script")
+class MakeWeightedChannels(torch.nn.Module):
+ weight_numel: int
+ multiplicity_out: Union[int, list]
+ _num_irreps: int
+
+ def __init__(
+ self,
+ irreps_in,
+ multiplicity_out: Union[int, list],
+ pad_to_alignment: int = 1,
+ ):
+ super().__init__()
+ assert all(mul == 1 for mul, _ in irreps_in)
+ assert multiplicity_out >= 1
+ # Each edgewise output multiplicity is a per-irrep weighted sum over the input
+ # So we need to apply the weight for the ith irrep to all DOF in that irrep
+ w_index = []
+ idx = 0
+ self._num_irreps = 0
+ for (mul, ir) in irreps_in:
+ w_index += sum(([ix] * ir.dim for ix in range(idx, idx + mul)), [])
+ idx += mul
+ self._num_irreps += mul
+ # w_index = sum(([i] * ir.dim for i, (mul, ir) in enumerate(irreps_in)), [])
+ # pad to padded length
+ n_pad = (
+ int(ceil(irreps_in.dim / pad_to_alignment)) * pad_to_alignment
+ - irreps_in.dim
+ )
+ # use the last weight, what we use doesn't matter much
+ w_index += [w_index[-1]] * n_pad
+ self.register_buffer("_w_index", torch.as_tensor(w_index, dtype=torch.long))
+ # there is
+ self.multiplicity_out = multiplicity_out
+ self.weight_numel = self._num_irreps * multiplicity_out
+
+ def forward(self, edge_attr, weights):
+ # weights are [z, u, num_i]
+ # edge_attr are [z, i]
+ # i runs over all irreps, which is why the weights need
+ # to be indexed in order to go from [num_i] to [i]
+ return torch.einsum(
+ "zi,zui->zui",
+ edge_attr,
+ weights.view(
+ -1,
+ self.multiplicity_out,
+ self._num_irreps,
+ )[:, :, self._w_index],
+ )
+
+@torch.jit.script
+def ShiftedSoftPlus(x):
+ return torch.nn.functional.softplus(x) - math.log(2.0)
+
+class ScalarMLPFunction(CodeGenMixin, torch.nn.Module):
+ """Module implementing an MLP according to provided options."""
+
+ in_features: int
+ out_features: int
+
+ def __init__(
+ self,
+ mlp_input_dimension: Optional[int],
+ mlp_latent_dimensions: List[int],
+ mlp_output_dimension: Optional[int],
+ mlp_nonlinearity: Optional[str] = "silu",
+ mlp_initialization: str = "normal",
+ mlp_dropout_p: float = 0.0,
+ mlp_batchnorm: bool = False,
+ ):
+ super().__init__()
+ nonlinearity = {
+ None: None,
+ "silu": torch.nn.functional.silu,
+ "ssp": ShiftedSoftPlus,
+ }[mlp_nonlinearity]
+ if nonlinearity is not None:
+ nonlin_const = normalize2mom(nonlinearity).cst
+ else:
+ nonlin_const = 1.0
+
+ dimensions = (
+ ([mlp_input_dimension] if mlp_input_dimension is not None else [])
+ + mlp_latent_dimensions
+ + ([mlp_output_dimension] if mlp_output_dimension is not None else [])
+ )
+ assert len(dimensions) >= 2 # Must have input and output dim
+ num_layers = len(dimensions) - 1
+
+ self.in_features = dimensions[0]
+ self.out_features = dimensions[-1]
+
+ # Code
+ params = {}
+ graph = fx.Graph()
+ tracer = fx.proxy.GraphAppendingTracer(graph)
+
+ def Proxy(n):
+ return fx.Proxy(n, tracer=tracer)
+
+ features = Proxy(graph.placeholder("x"))
+ norm_from_last: float = 1.0
+
+ base = torch.nn.Module()
+
+ for layer, (h_in, h_out) in enumerate(zip(dimensions, dimensions[1:])):
+ # do dropout
+ if mlp_dropout_p > 0:
+ # only dropout if it will do something
+ # dropout before linear projection- https://stats.stackexchange.com/a/245137
+ features = Proxy(graph.call_module("_dropout", (features.node,)))
+
+ # make weights
+ w = torch.empty(h_in, h_out)
+
+ if mlp_initialization == "normal":
+ w.normal_()
+ elif mlp_initialization == "uniform":
+ # these values give < x^2 > = 1
+ w.uniform_(-math.sqrt(3), math.sqrt(3))
+ elif mlp_initialization == "orthogonal":
+ # this rescaling gives < x^2 > = 1
+ torch.nn.init.orthogonal_(w, gain=math.sqrt(max(w.shape)))
+ else:
+ raise NotImplementedError(
+ f"Invalid mlp_initialization {mlp_initialization}"
+ )
+
+ # generate code
+ params[f"_weight_{layer}"] = w
+ w = Proxy(graph.get_attr(f"_weight_{layer}"))
+ w = w * (
+ norm_from_last / math.sqrt(float(h_in))
+ ) # include any nonlinearity normalization from previous layers
+ features = torch.matmul(features, w)
+
+ if mlp_batchnorm:
+ # if we call batchnorm, do it after the nonlinearity
+ features = Proxy(graph.call_module(f"_bn_{layer}", (features.node,)))
+ setattr(base, f"_bn_{layer}", torch.nn.BatchNorm1d(h_out))
+
+ # generate nonlinearity code
+ if nonlinearity is not None and layer < num_layers - 1:
+ features = nonlinearity(features)
+ # add the normalization const in next layer
+ norm_from_last = nonlin_const
+
+ graph.output(features.node)
+
+ for pname, p in params.items():
+ setattr(base, pname, torch.nn.Parameter(p))
+
+ if mlp_dropout_p > 0:
+ # with normal dropout everything blows up
+ base._dropout = torch.nn.AlphaDropout(p=mlp_dropout_p)
+
+ self._codegen_register({"_forward": fx.GraphModule(base, graph)})
+
+ def forward(self, x):
+ return self._forward(x)
+
+class InitLayer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ idp,
+ num_types: int,
+ n_radial_basis: int,
+ r_max: float,
+ irreps_sh: o3.Irreps=None,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ two_body_latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ env_embed_kwargs = {
+ "mlp_latent_dimensions": [],
+ "mlp_nonlinearity": None,
+ "mlp_initialization": "uniform"
+ },
+ # cutoffs
+ r_start_cos_ratio: float = 0.8,
+ PolynomialCutoff_p: float = 6,
+ cutoff_type: str = "polynomial",
+ device: Union[str, torch.device] = torch.device("cpu"),
+ dtype: Union[str, torch.dtype] = torch.float32,
+ ):
+ super(InitLayer, self).__init__()
+ SCALAR = o3.Irrep("0e")
+ self.num_types = num_types
+ if isinstance(r_max, float) or isinstance(r_max, int):
+ self.r_max = torch.tensor(r_max, device=device, dtype=dtype)
+ self.r_max_dict = None
+ elif isinstance(r_max, dict):
+ c_set = set(list(r_max.values()))
+ self.r_max = torch.tensor(max(list(r_max.values())), device=device, dtype=dtype)
+ if len(r_max) == 1 or len(c_set) == 1:
+ self.r_max_dict = None
+ else:
+ self.r_max_dict = {}
+ for k,v in r_max.items():
+ self.r_max_dict[k] = torch.tensor(v, device=device, dtype=dtype)
+ else:
+ raise TypeError("r_max should be either float, int or dict")
+
+ self.idp = idp
+ self.two_body_latent_kwargs = two_body_latent_kwargs
+ self.r_start_cos_ratio = r_start_cos_ratio
+ self.polynomial_cutoff_p = PolynomialCutoff_p
+ self.cutoff_type = cutoff_type
+ self.device = device
+ self.dtype = dtype
+ self.irreps_out = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+ # env_embed_irreps = o3.Irreps([(1, ir) for _, ir in irreps_sh])
+ assert (
+ irreps_sh[0].ir == SCALAR
+ ), "env_embed_irreps must start with scalars"
+
+ # Node invariants for center and neighbor (chemistry)
+ # Plus edge invariants for the edge (radius).
+ self.two_body_latent = ScalarMLPFunction(
+ mlp_input_dimension=(2 * num_types + n_radial_basis),
+ mlp_output_dimension=None,
+ **two_body_latent_kwargs,
+ )
+
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=self.irreps_out,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element", # if path normalization is element and input irreps has 1 mul, it should not have effect !
+ )
+
+ # self.bn = BatchNorm(
+ # irreps=self.irreps_out,
+ # affine=True,
+ # instance=False,
+ # normalization="component",
+ # )
+
+ self.env_embed_mlp = ScalarMLPFunction(
+ mlp_input_dimension=self.two_body_latent.out_features,
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ **env_embed_kwargs,
+ )
+
+ self.bessel = BesselBasis(r_max=self.r_max, num_basis=n_radial_basis, trainable=True)
+
+
+
+ def forward(self, edge_index, bond_type, edge_sh, edge_length, node_one_hot):
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ edge_invariants = self.bessel(edge_length)
+ node_invariants = node_one_hot
+
+ # Vectorized precompute per layer cutoffs
+ if self.r_max_dict is None:
+ if self.cutoff_type == "cosine":
+ cutoff_coeffs = cosine_cutoff(
+ edge_length,
+ self.r_max.reshape(-1),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+
+ elif self.cutoff_type == "polynomial":
+ cutoff_coeffs = polynomial_cutoff(
+ edge_length, self.r_max.reshape(-1), p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+ else:
+ cutoff_coeffs = torch.zeros(edge_index.shape[1], dtype=self.dtype, device=self.device)
+
+ for bond, ty in self.idp.bond_to_type.items():
+ mask = bond_type == ty
+ index = mask.nonzero().squeeze(-1)
+
+ if mask.any():
+ iatom, jatom = bond.split("-")
+ if self.cutoff_type == "cosine":
+ c_coeff = cosine_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ r_start_cos_ratio=self.r_start_cos_ratio,
+ ).flatten()
+ elif self.cutoff_type == "polynomial":
+ c_coeff = polynomial_cutoff(
+ edge_length[mask],
+ 0.5*(self.r_max_dict[iatom]+self.r_max_dict[jatom]),
+ p=self.polynomial_cutoff_p
+ ).flatten()
+
+ else:
+ # This branch is unreachable (cutoff type is checked in __init__)
+ # But TorchScript doesn't know that, so we need to make it explicitly
+ # impossible to make it past so it doesn't throw
+ # "cutoff_coeffs_all is not defined in the false branch"
+ assert False, "Invalid cutoff type"
+
+ cutoff_coeffs = torch.index_copy(cutoff_coeffs, 0, index, c_coeff)
+
+ # Determine which edges are still in play
+ prev_mask = cutoff_coeffs > 0
+ active_edges = (cutoff_coeffs > 0).nonzero().squeeze(-1)
+
+ # Compute latents
+ latents = torch.zeros(
+ (edge_sh.shape[0], self.two_body_latent.out_features),
+ dtype=edge_sh.dtype,
+ device=edge_sh.device,
+ )
+
+ new_latents = self.two_body_latent(torch.cat([
+ node_invariants[edge_center],
+ node_invariants[edge_neighbor],
+ edge_invariants,
+ ], dim=-1)[prev_mask])
+
+ # Apply cutoff, which propagates through to everything else
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+ weights = self.env_embed_mlp(latents[active_edges])
+
+ # embed initial edge
+ features = self._env_weighter(
+ edge_sh[prev_mask], weights
+ ) # features is edge_attr
+ # features = self.bn(features)
+
+ return latents, features, cutoff_coeffs, active_edges # the radial embedding x and the sperical hidden V
+
+class Layer(torch.nn.Module):
+ def __init__(
+ self,
+ # required params
+ num_types: int,
+ avg_num_neighbors: Optional[float] = None,
+ irreps_sh: o3.Irreps=None,
+ irreps_in: o3.Irreps=None,
+ irreps_out: o3.Irreps=None,
+ # general hyperparameters:
+ linear_after_env_embed: bool = False,
+ env_embed_multiplicity: int = 32,
+ # MLP parameters:
+ latent_kwargs={
+ "mlp_latent_dimensions": [128, 256, 512, 1024],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ latent_in: int=1024,
+ latent_resnet: bool = True,
+ latent_resnet_update_ratios: Optional[List[float]] = None,
+ latent_resnet_update_ratios_learnable: bool = False,
+ ):
+ super().__init__()
+ SCALAR = o3.Irrep("0e")
+ self.latent_resnet = latent_resnet
+ self.avg_num_neighbors = avg_num_neighbors
+ self.linear_after_env_embed = linear_after_env_embed
+ self.irreps_in = irreps_in
+ self.irreps_out = irreps_out
+
+ assert all(mul==1 for mul, _ in irreps_sh)
+
+ # for normalization of env embed sums
+ # one per layer
+ self.register_buffer(
+ "env_sum_normalizations",
+ # dividing by sqrt(N)
+ torch.as_tensor(avg_num_neighbors).rsqrt(),
+ )
+
+ latent = functools.partial(ScalarMLPFunction, **latent_kwargs)
+
+ self.latents = None
+ self.env_embed_mlps = None
+ self.tps = None
+ self.linears = None
+ self.env_linears = None
+
+ # Prune impossible paths
+ self.irreps_out = o3.Irreps(
+ [
+ (mul, ir)
+ for mul, ir in self.irreps_out
+ if tp_path_exists(irreps_sh, irreps_in, ir)
+ ]
+ )
+
+ mul_irreps_sh = o3.Irreps([(env_embed_multiplicity, ir) for _, ir in irreps_sh])
+ self._env_weighter = Linear(
+ irreps_in=irreps_sh,
+ irreps_out=mul_irreps_sh,
+ internal_weights=False,
+ shared_weights=False,
+ path_normalization = "element",
+ )
+
+ # == Remove unneeded paths ==
+ #TODO: add the remove unseen paths
+
+ if self.linear_after_env_embed:
+ self.env_linears = Linear(
+ mul_irreps_sh,
+ mul_irreps_sh,
+ shared_weights=True,
+ internal_weights=True,
+ )
+ else:
+ self.env_linears = torch.nn.Identity()
+
+ # # Make TP
+ # tmp_i_out: int = 0
+ # instr = []
+ # n_scalar_outs: int = 0
+ # n_scalar_mul = []
+ # full_out_irreps = []
+ # for i_out, (mul_out, ir_out) in enumerate(self.irreps_out):
+ # for i_1, (mul1, ir_1) in enumerate(self.irreps_in): # what if feature_irreps_in has mul?
+ # for i_2, (mul2, ir_2) in enumerate(self._env_weighter.irreps_out):
+ # if ir_out in ir_1 * ir_2:
+ # if ir_out == SCALAR:
+ # n_scalar_outs += 1
+ # n_scalar_mul.append(mul2)
+ # # assert mul_out == mul1 == mul2
+ # instr.append((i_1, i_2, tmp_i_out, 'uvv', True))
+ # full_out_irreps.append((mul2, ir_out))
+ # assert full_out_irreps[-1][0] == mul2
+ # tmp_i_out += 1
+ # full_out_irreps = o3.Irreps(full_out_irreps)
+ # assert all(ir == SCALAR for _, ir in full_out_irreps[:n_scalar_outs])
+ # self.n_scalar_mul = sum(n_scalar_mul)
+
+ self.lin_pre = Linear(
+ irreps_in=self.irreps_in,
+ irreps_out=self.irreps_in,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # self.tp = TensorProduct(
+ # irreps_in1=o3.Irreps(
+ # [(mul, ir) for mul, ir in self.irreps_in]
+ # ),
+ # irreps_in2=o3.Irreps(
+ # [(mul, ir) for mul, ir in self._env_weighter.irreps_out]
+ # ),
+ # irreps_out=o3.Irreps(
+ # [(mul, ir) for mul, ir in full_out_irreps]
+ # ),
+ # irrep_normalization="component",
+ # instructions=instr,
+ # shared_weights=True,
+ # internal_weights=True,
+ # )
+ # build activation
+
+ irreps_scalar = o3.Irreps(str(self.irreps_out[0]))
+ irreps_gated = o3.Irreps([(mul, ir) for mul, ir in self.irreps_out if ir.l > 0]).simplify()
+ irreps_gates = o3.Irreps([(mul, (0,1)) for mul, _ in irreps_gated]).simplify()
+ act={1: torch.nn.functional.silu, -1: torch.tanh}
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+
+ self.activation = Gate(
+ irreps_scalar, [act[ir.p] for _, ir in irreps_scalar], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ self.tp = SeparateWeightTensorProduct(
+ irreps_in1=self._env_weighter.irreps_out+self.irreps_in+self._env_weighter.irreps_out,
+ irreps_in2=irreps_sh,
+ irreps_out=self.activation.irreps_in,
+ )
+
+ # self.sc = FullyConnectedTensorProduct(
+ # irreps_in,
+ # o3.Irreps(str(2*num_types)+"x0e"),
+ # self.irreps_out,
+ # shared_weights=True,
+ # internal_weights=True
+ # )
+
+ self.lin_post = Linear(
+ self.irreps_out,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ self.bn = BatchNorm(
+ irreps=self.irreps_out,
+ affine=True,
+ instance=False,
+ normalization="component",
+ )
+
+ self.linear_res = Linear(
+ self.irreps_in,
+ self.irreps_out,
+ shared_weights=True,
+ internal_weights=True,
+ biases=True,
+ )
+
+ # we extract the scalars from the first irrep of the tp
+ # assert full_out_irreps[0].ir == SCALAR
+ # self.linears = Linear(
+ # irreps_in=full_out_irreps,
+ # irreps_out=self.activation.irreps_in,
+ # shared_weights=True,
+ # internal_weights=True,
+ # biases=True,
+ # )
+
+ # the embedded latent invariants from the previous layer(s)
+ # and the invariants extracted from the last layer's TP:
+ self.latents = latent(
+ mlp_input_dimension=latent_in+self.irreps_out[0].dim,
+ mlp_output_dimension=None,
+ )
+
+ # the env embed MLP takes the last latent's output as input
+ # and outputs enough weights for the env embedder
+ self.env_embed_mlps = ScalarMLPFunction(
+ mlp_input_dimension=latent_in,
+ mlp_latent_dimensions=[],
+ mlp_output_dimension=self._env_weighter.weight_numel,
+ )
+ # - layer resnet update weights -
+ if latent_resnet_update_ratios is None:
+ # We initialize to zeros, which under the sigmoid() become 0.5
+ # so 1/2 * layer_1 + 1/4 * layer_2 + ...
+ # note that the sigmoid of these are the factor _between_ layers
+ # so the first entry is the ratio for the latent resnet of the first and second layers, etc.
+ # e.g. if there are 3 layers, there are 2 ratios: l1:l2, l2:l3
+ latent_resnet_update_params = torch.zeros(1)
+ else:
+ latent_resnet_update_ratios = torch.as_tensor(
+ latent_resnet_update_ratios, dtype=torch.get_default_dtype()
+ )
+ assert latent_resnet_update_ratios > 0.0
+ assert latent_resnet_update_ratios < 1.0
+ latent_resnet_update_params = torch.special.logit(
+ latent_resnet_update_ratios
+ )
+ # The sigmoid is mostly saturated at ±6, keep it in a reasonable range
+ latent_resnet_update_params.clamp_(-6.0, 6.0)
+
+ if latent_resnet_update_ratios_learnable:
+ self._latent_resnet_update_params = torch.nn.Parameter(
+ latent_resnet_update_params
+ )
+ else:
+ self.register_buffer(
+ "_latent_resnet_update_params", latent_resnet_update_params
+ )
+
+ def forward(self, edge_index, edge_sh, atom_type, latents, features, cutoff_coeffs, active_edges):
+ # update V
+ # update X
+ # edge_index: [2, num_edges]
+ # irreps_sh: [num_edges, irreps_sh]
+ # latents: [num_edges, latent_in]
+ # fetures: [num_active_edges, in_irreps]
+ # cutoff_coeffs: [num_edges]
+ # active_edges: [num_active_edges]
+
+ edge_center = edge_index[0]
+ edge_neighbor = edge_index[1]
+
+ prev_mask = cutoff_coeffs > 0
+
+ # sc_features = self.sc(features, node_one_hot[edge_index].transpose(0,1).flatten(1,2)[active_edges])
+ # update V
+ weights = self.env_embed_mlps(latents[active_edges])
+
+ # Build the local environments
+ # This local environment should only be a sum over neighbors
+ # who are within the cutoff of the _current_ layer
+ # Those are the active edges, which are the only ones we
+ # have weights for (env_w) anyway.
+ # So we mask out the edges in the sum:
+ local_env_per_edge = scatter(
+ self._env_weighter(edge_sh[active_edges], weights),
+ edge_center[active_edges],
+ dim=0,
+ )
+
+ # currently, we have a sum over neighbors of constant number for each layer,
+ # the env_sum_normalization can be a scalar or list
+ # the different cutoff can be added in the future
+
+ if self.env_sum_normalizations.ndim < 1:
+ norm_const = self.env_sum_normalizations
+ else:
+ norm_const = self.env_sum_normalizations[atom_type.flatten()].unsqueeze(-1)
+
+ local_env_per_edge = local_env_per_edge * norm_const
+ local_env_per_edge = self.env_linears(local_env_per_edge)
+
+ # local_env_per_edge = torch.cat([local_env_per_edge[edge_center[active_edges]], local_env_per_edge[edge_neighbor[active_edges]]], dim=-1)
+ # local_env_per_edge = local_env_per_edge[edge_center[active_edges]]
+ # Now do the TP
+ # recursively tp current features with the environment embeddings
+ new_features = self.tp(
+ torch.cat(
+ [
+ local_env_per_edge[edge_center[active_edges]],
+ self.lin_pre(features),
+ local_env_per_edge[edge_neighbor[active_edges]]
+ ], dim=-1),
+ edge_sh[active_edges]) # full_out_irreps
+
+ new_features = self.activation(new_features)
+ # # do the linear
+ # new_features = self.linears(new_features)
+
+
+ # features has shape [N_edge, full_feature_out.dim]
+ # we know scalars are first
+ scalars = new_features[:, :self.irreps_out[0].dim]
+ assert len(scalars.shape) == 2
+
+ new_features = self.lin_post(new_features)
+
+ new_features = self.bn(new_features)
+
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ features = coefficient_new * new_features + coefficient_old * self.linear_res(features)
+ else:
+ features = new_features
+
+ # update X
+ latent_inputs_to_cat = [
+ latents[active_edges],
+ scalars,
+ ]
+
+ new_latents = self.latents(torch.cat(latent_inputs_to_cat, dim=-1))
+ new_latents = cutoff_coeffs[active_edges].unsqueeze(-1) * new_latents
+ # At init, we assume new and old to be approximately uncorrelated
+ # Thus their variances add
+ # we always want the latent space to be normalized to variance = 1.0,
+ # because it is critical for learnability. Still, we want to preserve
+ # the _relative_ magnitudes of the current latent and the residual update
+ # to be controled by `this_layer_update_coeff`
+ # Solving the simple system for the two coefficients:
+ # a^2 + b^2 = 1 (variances add) & a * this_layer_update_coeff = b
+ # gives
+ # a = 1 / sqrt(1 + this_layer_update_coeff^2) & b = this_layer_update_coeff / sqrt(1 + this_layer_update_coeff^2)
+ # rsqrt is reciprocal sqrt
+ if self.latent_resnet:
+ update_coefficients = self._latent_resnet_update_params.sigmoid()
+ coefficient_old = torch.rsqrt(update_coefficients.square() + 1)
+ coefficient_new = update_coefficients * coefficient_old
+ latents = torch.index_add(
+ coefficient_old * latents,
+ 0,
+ active_edges,
+ coefficient_new * new_latents,
+ )
+ else:
+ latents = torch.index_copy(latents, 0, active_edges, new_latents)
+
+ return latents, features, cutoff_coeffs, active_edges
+
\ No newline at end of file
diff --git a/dptb/nn/embedding/emb.py b/dptb/nn/embedding/emb.py
new file mode 100644
index 00000000..85f976bd
--- /dev/null
+++ b/dptb/nn/embedding/emb.py
@@ -0,0 +1,28 @@
+import torch.nn as nn
+import torch
+from dptb.utils.register import Register
+
+"""this is the register class for descriptors
+
+all descriptors inplemendeted should be a instance of nn.Module class, and provide a forward function that
+takes AtomicData class as input, and give AtomicData class as output.
+
+"""
+class Embedding:
+ _register = Register()
+
+ def register(target):
+ return Embedding._register.register(target)
+
+ def __new__(cls, method: str, **kwargs):
+ if method in Embedding._register.keys():
+ return Embedding._register[method](**kwargs)
+ else:
+ raise Exception(f"Descriptor mode: {method} is not registered!")
+
+
+
+
+
+
+
diff --git a/dptb/nnsktb/__init__.py b/dptb/nn/embedding/from_deephe3/__init__.py
similarity index 100%
rename from dptb/nnsktb/__init__.py
rename to dptb/nn/embedding/from_deephe3/__init__.py
diff --git a/dptb/nn/embedding/from_deephe3/deephe3.py b/dptb/nn/embedding/from_deephe3/deephe3.py
new file mode 100644
index 00000000..1a8023da
--- /dev/null
+++ b/dptb/nn/embedding/from_deephe3/deephe3.py
@@ -0,0 +1,469 @@
+import warnings
+import os
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch_scatter import scatter
+from e3nn.nn import Gate
+from e3nn.o3 import Irreps, Linear, SphericalHarmonics, FullyConnectedTensorProduct
+import e3nn.o3 as o3
+from ...radial_basis import GaussianBasis
+from .e3module import SphericalBasis, sort_irreps, e3LayerNorm, e3ElementWise, SkipConnection, SeparateWeightTensorProduct, SelfTp
+from dptb.data import AtomicDataDict
+
+epsilon = 1e-8
+
+def tp_path_exists(irreps_in1, irreps_in2, ir_out):
+ irreps_in1 = o3.Irreps(irreps_in1).simplify()
+ irreps_in2 = o3.Irreps(irreps_in2).simplify()
+ ir_out = o3.Irrep(ir_out)
+
+ for _, ir1 in irreps_in1:
+ for _, ir2 in irreps_in2:
+ if ir_out in ir1 * ir2:
+ return True
+ return False
+
+def get_gate_nonlin(irreps_in1, irreps_in2, irreps_out,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh}
+ ):
+ # get gate nonlinearity after tensor product
+ # irreps_in1 and irreps_in2 are irreps to be multiplied in tensor product
+ # irreps_out is desired irreps after gate nonlin
+ # notice that nonlin.irreps_out might not be exactly equal to irreps_out
+
+ irreps_scalars = Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l == 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ irreps_gated = Irreps([
+ (mul, ir)
+ for mul, ir in irreps_out
+ if ir.l > 0 and tp_path_exists(irreps_in1, irreps_in2, ir)
+ ]).simplify()
+ if irreps_gated.dim > 0:
+ if tp_path_exists(irreps_in1, irreps_in2, "0e"):
+ ir = "0e"
+ elif tp_path_exists(irreps_in1, irreps_in2, "0o"):
+ ir = "0o"
+ warnings.warn('Using odd representations as gates')
+ else:
+ raise ValueError(
+ f"irreps_in1={irreps_in1} times irreps_in2={irreps_in2} is unable to produce gates needed for irreps_gated={irreps_gated}")
+ else:
+ ir = None
+ irreps_gates = Irreps([(mul, ir) for mul, _ in irreps_gated]).simplify()
+
+ gate_nonlin = Gate(
+ irreps_scalars, [act[ir.p] for _, ir in irreps_scalars], # scalar
+ irreps_gates, [act_gates[ir.p] for _, ir in irreps_gates], # gates (scalars)
+ irreps_gated # gated tensors
+ )
+
+ return gate_nonlin
+
+
+class EquiConv(nn.Module):
+ def __init__(self, fc_len_in, irreps_in1, irreps_in2, irreps_out, norm='', nonlin=True,
+ act = {1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates = {1: torch.sigmoid, -1: torch.tanh}
+ ):
+ super(EquiConv, self).__init__()
+
+ irreps_in1 = Irreps(irreps_in1)
+ irreps_in2 = Irreps(irreps_in2)
+ irreps_out = Irreps(irreps_out)
+
+ self.nonlin = None
+ if nonlin:
+ self.nonlin = get_gate_nonlin(irreps_in1, irreps_in2, irreps_out, act, act_gates)
+ irreps_tp_out = self.nonlin.irreps_in
+ else:
+ irreps_tp_out = Irreps([(mul, ir) for mul, ir in irreps_out if tp_path_exists(irreps_in1, irreps_in2, ir)])
+
+ self.tp = SeparateWeightTensorProduct(irreps_in1, irreps_in2, irreps_tp_out)
+
+ if nonlin:
+ self.cfconv = e3ElementWise(self.nonlin.irreps_out)
+ self.irreps_out = self.nonlin.irreps_out
+ else:
+ self.cfconv = e3ElementWise(irreps_tp_out)
+ self.irreps_out = irreps_tp_out
+
+ # fully connected net to create tensor product weights
+ linear_act = nn.SiLU()
+ self.fc = nn.Sequential(nn.Linear(fc_len_in, 64),
+ linear_act,
+ nn.Linear(64, 64),
+ linear_act,
+ nn.Linear(64, self.cfconv.len_weight)
+ )
+
+ self.norm = None
+ if norm:
+ if norm == 'e3LayerNorm':
+ self.norm = e3LayerNorm(self.cfconv.irreps_in)
+ else:
+ raise ValueError(f'unknown norm: {norm}')
+
+ def forward(self, fea_in1, fea_in2, fea_weight, batch_edge):
+ z = self.tp(fea_in1, fea_in2)
+
+ if self.nonlin is not None:
+ z = self.nonlin(z)
+
+ weight = self.fc(fea_weight)
+ z = self.cfconv(z, weight)
+
+ if self.norm is not None:
+ z = self.norm(z, batch_edge)
+
+ # TODO self-connection here
+ return z
+
+
+class NodeUpdateBlock(nn.Module):
+ def __init__(self, num_species, fc_len_in, irreps_sh, irreps_in_node, irreps_out_node, irreps_in_edge,
+ act, act_gates, use_selftp=False, use_sc=True, concat=True, only_ij=False, nonlin=False, norm='e3LayerNorm', if_sort_irreps=False):
+ super(NodeUpdateBlock, self).__init__()
+ irreps_in_node = Irreps(irreps_in_node)
+ irreps_sh = Irreps(irreps_sh)
+ irreps_out_node = Irreps(irreps_out_node)
+ irreps_in_edge = Irreps(irreps_in_edge)
+
+ if concat:
+ irreps_in1 = irreps_in_node + irreps_in_node + irreps_in_edge
+ if if_sort_irreps:
+ self.sort = sort_irreps(irreps_in1)
+ irreps_in1 = self.sort.irreps_out
+ else:
+ irreps_in1 = irreps_in_node
+ irreps_in2 = irreps_sh
+
+ self.lin_pre = Linear(irreps_in=irreps_in_node, irreps_out=irreps_in_node, biases=True)
+
+ self.nonlin = None
+ if nonlin:
+ self.nonlin = get_gate_nonlin(irreps_in1, irreps_in2, irreps_out_node, act, act_gates)
+ irreps_conv_out = self.nonlin.irreps_in
+ conv_nonlin = False
+ else:
+ irreps_conv_out = irreps_out_node
+ conv_nonlin = True
+
+ self.conv = EquiConv(fc_len_in, irreps_in1, irreps_in2, irreps_conv_out, nonlin=conv_nonlin, act=act, act_gates=act_gates)
+ self.lin_post = Linear(irreps_in=self.conv.irreps_out, irreps_out=self.conv.irreps_out, biases=True)
+
+ if nonlin:
+ self.irreps_out = self.nonlin.irreps_out
+ else:
+ self.irreps_out = self.conv.irreps_out
+
+ self.sc = None
+ if use_sc:
+ self.sc = FullyConnectedTensorProduct(irreps_in_node, f'{num_species}x0e', self.conv.irreps_out)
+
+ self.norm = None
+ if norm:
+ if norm == 'e3LayerNorm':
+ self.norm = e3LayerNorm(self.irreps_out)
+ else:
+ raise ValueError(f'unknown norm: {norm}')
+
+ self.skip_connect = SkipConnection(irreps_in_node, self.irreps_out)
+
+ self.self_tp = None
+ if use_selftp:
+ self.self_tp = SelfTp(self.irreps_out, self.irreps_out)
+
+ self.irreps_in_node = irreps_in_node
+ self.use_sc = use_sc
+ self.concat = concat
+ self.only_ij = only_ij
+ self.if_sort_irreps = if_sort_irreps
+
+ def forward(self, node_fea, node_one_hot, edge_sh, edge_fea, edge_length_embedded, edge_index, batch, selfloop_edge, edge_length):
+
+ node_fea_old = node_fea
+
+ if self.use_sc:
+ node_self_connection = self.sc(node_fea, node_one_hot)
+
+ node_fea = self.lin_pre(node_fea)
+
+ index_i = edge_index[0]
+ index_j = edge_index[1]
+ if self.concat:
+ fea_in = torch.cat([node_fea[index_i], node_fea[index_j], edge_fea], dim=-1)
+ if self.if_sort_irreps:
+ fea_in = self.sort(fea_in)
+ edge_update = self.conv(fea_in, edge_sh, edge_length_embedded, batch[edge_index[0]])
+ else:
+ edge_update = self.conv(node_fea[index_j], edge_sh, edge_length_embedded, batch[edge_index[0]])
+
+ # sigma = 3
+ # n = 2
+ # edge_update = edge_update * torch.exp(- edge_length ** n / sigma ** n / 2).view(-1, 1)
+
+ node_fea = scatter(edge_update, index_i, dim=0, dim_size=node_fea.shape[0], reduce='add')
+ if self.only_ij:
+ node_fea = node_fea + scatter(edge_update[~selfloop_edge], index_j[~selfloop_edge], dim=0, dim_size=node_fea.shape[0], reduce='add')
+
+ node_fea = self.lin_post(node_fea)
+
+ if self.use_sc:
+ node_fea = node_fea + node_self_connection
+
+ if self.nonlin is not None:
+ node_fea = self.nonlin(node_fea)
+
+ if self.norm is not None:
+ node_fea = self.norm(node_fea, batch)
+
+ node_fea = self.skip_connect(node_fea_old, node_fea)
+
+ if self.self_tp is not None:
+ node_fea = self.self_tp(node_fea)
+
+ return node_fea
+
+
+class EdgeUpdateBlock(nn.Module):
+ def __init__(self, num_species, fc_len_in, irreps_sh, irreps_in_node, irreps_in_edge, irreps_out_edge,
+ act, act_gates, use_selftp=False, use_sc=True, init_edge=False, nonlin=False, norm='e3LayerNorm', if_sort_irreps=False):
+ super(EdgeUpdateBlock, self).__init__()
+ irreps_in_node = Irreps(irreps_in_node)
+ irreps_in_edge = Irreps(irreps_in_edge)
+ irreps_out_edge = Irreps(irreps_out_edge)
+
+ irreps_in1 = irreps_in_node + irreps_in_node + irreps_in_edge
+ if if_sort_irreps:
+ self.sort = sort_irreps(irreps_in1)
+ irreps_in1 = self.sort.irreps_out
+ irreps_in2 = irreps_sh
+
+ self.lin_pre = Linear(irreps_in=irreps_in_edge, irreps_out=irreps_in_edge, biases=True)
+
+ self.nonlin = None
+ self.lin_post = None
+ if nonlin:
+ self.nonlin = get_gate_nonlin(irreps_in1, irreps_in2, irreps_out_edge, act, act_gates)
+ irreps_conv_out = self.nonlin.irreps_in
+ conv_nonlin = False
+ else:
+ irreps_conv_out = irreps_out_edge
+ conv_nonlin = True
+
+ self.conv = EquiConv(fc_len_in, irreps_in1, irreps_in2, irreps_conv_out, nonlin=conv_nonlin, act=act, act_gates=act_gates)
+ self.lin_post = Linear(irreps_in=self.conv.irreps_out, irreps_out=self.conv.irreps_out, biases=True)
+
+ if use_sc:
+ self.sc = FullyConnectedTensorProduct(irreps_in_edge, f'{num_species**2}x0e', self.conv.irreps_out)
+
+ if nonlin:
+ self.irreps_out = self.nonlin.irreps_out
+ else:
+ self.irreps_out = self.conv.irreps_out
+
+ self.norm = None
+ if norm:
+ if norm == 'e3LayerNorm':
+ self.norm = e3LayerNorm(self.irreps_out)
+ else:
+ raise ValueError(f'unknown norm: {norm}')
+
+ self.skip_connect = SkipConnection(irreps_in_edge, self.irreps_out) # ! consider init_edge
+
+ self.self_tp = None
+ if use_selftp:
+ self.self_tp = SelfTp(self.irreps_out, self.irreps_out)
+
+ self.use_sc = use_sc
+ self.init_edge = init_edge
+ self.if_sort_irreps = if_sort_irreps
+ self.irreps_in_edge = irreps_in_edge
+
+ def forward(self, node_fea, edge_one_hot, edge_sh, edge_fea, edge_length_embedded, edge_index, batch):
+
+ if not self.init_edge:
+ edge_fea_old = edge_fea
+ if self.use_sc:
+ edge_self_connection = self.sc(edge_fea, edge_one_hot)
+ edge_fea = self.lin_pre(edge_fea)
+
+ index_i = edge_index[0]
+ index_j = edge_index[1]
+ fea_in = torch.cat([node_fea[index_i], node_fea[index_j], edge_fea], dim=-1)
+ if self.if_sort_irreps:
+ fea_in = self.sort(fea_in)
+ edge_fea = self.conv(fea_in, edge_sh, edge_length_embedded, batch[edge_index[0]])
+
+ edge_fea = self.lin_post(edge_fea)
+
+ if self.use_sc:
+ edge_fea = edge_fea + edge_self_connection
+
+ if self.nonlin is not None:
+ edge_fea = self.nonlin(edge_fea)
+
+ if self.norm is not None:
+ edge_fea = self.norm(edge_fea, batch[edge_index[0]])
+
+ if not self.init_edge:
+ edge_fea = self.skip_connect(edge_fea_old, edge_fea)
+
+ if self.self_tp is not None:
+ edge_fea = self.self_tp(edge_fea)
+
+ return edge_fea
+
+
+class Net(nn.Module):
+ def __init__(self, num_species, # spherical basis irreps
+ irreps_embed_node, irreps_sh, irreps_mid_node, irreps_post_node, irreps_out_node,
+ irreps_edge_init, irreps_mid_edge, irreps_post_edge, irreps_out_edge,
+ num_block, r_max, use_sc=True, no_parity=False, use_sbf=True, selftp=False, edge_upd=True,
+ only_ij=False, num_basis=128,
+ act={1: torch.nn.functional.silu, -1: torch.tanh},
+ act_gates={1: torch.sigmoid, -1: torch.tanh},
+ if_sort_irreps=False):
+
+ if no_parity:
+ for irreps in (irreps_embed_node, irreps_edge_init, irreps_sh, irreps_mid_node,
+ irreps_post_node, irreps_out_node,irreps_mid_edge, irreps_post_edge, irreps_out_edge,):
+ for _, ir in Irreps(irreps):
+ assert ir.p == 1, 'Ignoring parity but requiring representations with odd parity in net'
+
+ super(Net, self).__init__()
+ self.num_species = num_species
+ self.only_ij = only_ij
+
+ irreps_embed_node = Irreps(irreps_embed_node)
+ assert irreps_embed_node == Irreps(f'{irreps_embed_node.dim}x0e')
+ self.embedding = Linear(irreps_in=f"{num_species}x0e", irreps_out=irreps_embed_node) # node embedding
+
+ # edge embedding for tensor product weight
+ # self.basis = BesselBasis(r_max, num_basis=num_basis, trainable=False)
+ # self.cutoff = PolynomialCutoff(r_max, p=6)
+ self.basis = GaussianBasis(start=0.0, stop=r_max, n_gaussians=num_basis, trainable=False)
+
+ # distance expansion to initialize edge feature
+ irreps_edge_init = Irreps(irreps_edge_init)
+ assert irreps_edge_init == Irreps(f'{irreps_edge_init.dim}x0e')
+ self.distance_expansion = GaussianBasis(
+ start=0.0, stop=6.0, n_gaussians=irreps_edge_init.dim, trainable=False
+ )
+
+ if use_sbf:
+ self.sh = SphericalBasis(irreps_sh, r_max)
+ else:
+ self.sh = SphericalHarmonics(
+ irreps_out=irreps_sh,
+ normalize=True,
+ normalization='component',
+ )
+ self.use_sbf = use_sbf
+ if no_parity:
+ irreps_sh = Irreps([(mul, (ir.l, 1)) for mul, ir in Irreps(irreps_sh)])
+ self.irreps_sh = irreps_sh
+
+ # self.edge_update_block_init = EdgeUpdateBlock(num_basis, irreps_sh, self.embedding.irreps_out, None, irreps_mid_edge, act, act_gates, False, init_edge=True)
+ irreps_node_prev = self.embedding.irreps_out
+ irreps_edge_prev = irreps_edge_init
+
+ self.node_update_blocks = nn.ModuleList([])
+ self.edge_update_blocks = nn.ModuleList([])
+ for index_block in range(num_block):
+ if index_block == num_block - 1:
+ node_update_block = NodeUpdateBlock(num_species, num_basis, irreps_sh, irreps_node_prev, irreps_post_node, irreps_edge_prev, act, act_gates, use_selftp=selftp, use_sc=use_sc, only_ij=only_ij, if_sort_irreps=if_sort_irreps)
+ edge_update_block = EdgeUpdateBlock(num_species, num_basis, irreps_sh, node_update_block.irreps_out, irreps_edge_prev, irreps_post_edge, act, act_gates, use_selftp=selftp, use_sc=use_sc, if_sort_irreps=if_sort_irreps)
+ else:
+ node_update_block = NodeUpdateBlock(num_species, num_basis, irreps_sh, irreps_node_prev, irreps_mid_node, irreps_edge_prev, act, act_gates, use_selftp=False, use_sc=use_sc, only_ij=only_ij, if_sort_irreps=if_sort_irreps)
+ edge_update_block = None
+ if edge_upd:
+ edge_update_block = EdgeUpdateBlock(num_species, num_basis, irreps_sh, node_update_block.irreps_out, irreps_edge_prev, irreps_mid_edge, act, act_gates, use_selftp=False, use_sc=use_sc, if_sort_irreps=if_sort_irreps)
+ irreps_node_prev = node_update_block.irreps_out
+ if edge_update_block is not None:
+ irreps_edge_prev = edge_update_block.irreps_out
+ self.node_update_blocks.append(node_update_block)
+ self.edge_update_blocks.append(edge_update_block)
+
+ irreps_out_edge = Irreps(irreps_out_edge)
+ for _, ir in irreps_out_edge:
+ assert ir in irreps_edge_prev, f'required ir {ir} in irreps_out_edge cannot be produced by convolution in the last edge update block ({edge_update_block.irreps_in_edge} -> {edge_update_block.irreps_out})'
+
+ self.irreps_out_node = irreps_out_node
+ self.irreps_out_edge = irreps_out_edge
+ self.lin_node = Linear(irreps_in=irreps_node_prev, irreps_out=irreps_out_node, biases=True)
+ self.lin_edge = Linear(irreps_in=irreps_edge_prev, irreps_out=irreps_out_edge, biases=True)
+
+ def forward(self, data):
+ node_one_hot = F.one_hot(data[AtomicDataDict.ATOM_TYPE_KEY].flatten(), num_classes=self.num_species).type(torch.get_default_dtype())
+ edge_one_hot = F.one_hot(self.num_species * data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[data[AtomicDataDict.EDGE_INDEX_KEY][0]] + data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[data[AtomicDataDict.EDGE_INDEX_KEY][1]],
+ num_classes=self.num_species**2).type(torch.get_default_dtype()) # ! might not be good if dataset has many elements
+ # env_one_hot = F.one_hot(self.num_species * data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[data[AtomicDataDict.ENV_INDEX_KEY][0]] + data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[data[AtomicDataDict.ENV_INDEX_KEY][1]],
+ # num_classes=self.num_species**2).type(torch.get_default_dtype()) # ! might not be good if dataset has many elements
+
+ node_fea = self.embedding(node_one_hot)
+
+ edge_length = data[AtomicDataDict.EDGE_LENGTH_KEY]
+ edge_vec = torch.cat([edge_length.reshape(-1, 1), data[AtomicDataDict.EDGE_VECTORS_KEY][:, [1, 2, 0]]], dim=-1) # (y, z, x) order
+ # env_length = data[AtomicDataDict.ENV_LENGTH_KEY]
+ # env_vec = torch.cat([env_length.reshape(-1, 1), data[AtomicDataDict.ENV_VECTORS_KEY][:, [1, 2, 0]]], dim=-1) # (y, z, x) order
+
+ if self.use_sbf:
+ edge_sh = self.sh(edge_length, edge_vec)
+ # env_sh = self.sh(env_length, env_vec)
+ else:
+ edge_sh = self.sh(edge_vec).type(torch.get_default_dtype())
+ # env_sh = self.sh(env_vec).type(torch.get_default_dtype())
+ # edge_length_embedded = (self.basis(data["edge_attr"][:, 0] + epsilon) * self.cutoff(data["edge_attr"][:, 0])[:, None]).type(torch.get_default_dtype())
+ edge_length_embedded = self.basis(edge_length)
+ # env_length_embedded = self.basis(env_length)
+
+ selfloop_edge = None
+ if self.only_ij:
+ selfloop_edge = edge_length < 1e-7
+
+ # edge_fea = self.edge_update_block_init(node_fea, edge_sh, None, edge_length_embedded, data["edge_index"])
+ edge_fea = self.distance_expansion(edge_length).type(torch.get_default_dtype())
+ # env_fea = self.distance_expansion(env_length).type(torch.get_default_dtype())
+ for node_update_block, edge_update_block in zip(self.node_update_blocks, self.edge_update_blocks):
+ node_fea = node_update_block(node_fea, node_one_hot, edge_sh, edge_fea, edge_length_embedded, data[AtomicDataDict.EDGE_INDEX_KEY], data[AtomicDataDict.BATCH_KEY], selfloop_edge, edge_length)
+ if edge_update_block is not None:
+ edge_fea = edge_update_block(node_fea, edge_one_hot, edge_sh, edge_fea, edge_length_embedded, data[AtomicDataDict.EDGE_INDEX_KEY], data[AtomicDataDict.BATCH_KEY])
+ # env_fea = edge_update_block(node_fea, env_one_hot, env_sh, env_fea, env_length_embedded, data[AtomicDataDict.ENV_INDEX_KEY], data[AtomicDataDict.BATCH_KEY])
+
+ node_fea = self.lin_node(node_fea)
+ edge_fea = self.lin_edge(edge_fea)
+
+ return node_fea, edge_fea
+
+ def __repr__(self):
+ info = '===== DeepH-E3 model structure: ====='
+ if self.use_sbf:
+ info += f'\nusing spherical bessel basis: {self.irreps_sh}'
+ else:
+ info += f'\nusing spherical harmonics: {self.irreps_sh}'
+ for index, (nupd, eupd) in enumerate(zip(self.node_update_blocks, self.edge_update_blocks)):
+ info += f'\n=== layer {index} ==='
+ info += f'\nnode update: ({nupd.irreps_in_node} -> {nupd.irreps_out})'
+ if eupd is not None:
+ info += f'\nedge update: ({eupd.irreps_in_edge} -> {eupd.irreps_out})'
+ info += '\n=== output ==='
+ info += f'\noutput node: ({self.irreps_out_node})'
+ info += f'\noutput edge: ({self.irreps_out_edge})'
+
+ return info
+
+ def analyze_tp(self, path):
+ os.makedirs(path, exist_ok=True)
+ for index, (nupd, eupd) in enumerate(zip(self.node_update_blocks, self.edge_update_blocks)):
+ fig, ax = nupd.conv.tp.visualize()
+ fig.savefig(os.path.join(path, f'node_update_{index}.png'))
+ fig.clf()
+ fig, ax = eupd.conv.tp.visualize()
+ fig.savefig(os.path.join(path, f'edge_update_{index}.png'))
+ fig.clf()
diff --git a/dptb/nn/embedding/from_deephe3/e3module.py b/dptb/nn/embedding/from_deephe3/e3module.py
new file mode 100644
index 00000000..60de7112
--- /dev/null
+++ b/dptb/nn/embedding/from_deephe3/e3module.py
@@ -0,0 +1,367 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch_scatter import scatter
+from torch_geometric.utils import degree
+from scipy.optimize import brentq
+from scipy import special as sp
+from e3nn.util.jit import compile_mode
+from e3nn.o3 import Irrep, Irreps, wigner_3j, matrix_to_angles, Linear, FullyConnectedTensorProduct, TensorProduct, SphericalHarmonics
+from e3nn.nn import Extract
+import numpy as np
+from typing import Union
+import e3nn.o3 as o3
+from ...cutoff import polynomial_cutoff
+import sympy as sym
+
+
+def spherical_bessel_formulas(n):
+ """
+ Computes the sympy formulas for the spherical bessel functions up to order n (excluded)
+ """
+ x = sym.symbols('x')
+
+ f = [sym.sin(x)/x]
+ a = sym.sin(x)/x
+ for i in range(1, n):
+ b = sym.diff(a, x)/x
+ f += [sym.simplify(b*(-x)**i)]
+ a = sym.simplify(b)
+ return f
+
+def Jn(r, n):
+ """
+ numerical spherical bessel functions of order n
+ """
+ return np.sqrt(np.pi/(2*r)) * sp.jv(n+0.5, r)
+
+
+def Jn_zeros(n, k):
+ """
+ Compute the first k zeros of the spherical bessel functions up to order n (excluded)
+ """
+ zerosj = np.zeros((n, k), dtype="float32")
+ zerosj[0] = np.arange(1, k + 1) * np.pi
+ points = np.arange(1, k + n) * np.pi
+ racines = np.zeros(k + n - 1, dtype="float32")
+ for i in range(1, n):
+ for j in range(k + n - 1 - i):
+ foo = brentq(Jn, points[j], points[j + 1], (i,))
+ racines[j] = foo
+ points = racines
+ zerosj[i][:k] = racines[:k]
+
+ return zerosj
+
+def bessel_basis(n, k):
+ """
+ Compute the sympy formulas for the normalized and rescaled spherical bessel functions up to
+ order n (excluded) and maximum frequency k (excluded).
+ """
+
+ zeros = Jn_zeros(n, k)
+ normalizer = []
+ for order in range(n):
+ normalizer_tmp = []
+ for i in range(k):
+ normalizer_tmp += [0.5*Jn(zeros[order, i], order+1)**2]
+ normalizer_tmp = 1/np.array(normalizer_tmp)**0.5
+ normalizer += [normalizer_tmp]
+
+ f = spherical_bessel_formulas(n)
+ x = sym.symbols('x')
+ bess_basis = []
+ for order in range(n):
+ bess_basis_tmp = []
+ for i in range(k):
+ bess_basis_tmp += [sym.simplify(normalizer[order]
+ [i]*f[order].subs(x, zeros[order, i]*x))]
+ bess_basis += [bess_basis_tmp]
+ return bess_basis
+
+class sort_irreps(torch.nn.Module):
+ def __init__(self, irreps_in):
+ super().__init__()
+ irreps_in = Irreps(irreps_in)
+ sorted_irreps = irreps_in.sort()
+
+ irreps_out_list = [((mul, ir),) for mul, ir in sorted_irreps.irreps]
+ instructions = [(i,) for i in sorted_irreps.inv]
+ self.extr = Extract(irreps_in, irreps_out_list, instructions)
+
+ irreps_in_list = [((mul, ir),) for mul, ir in irreps_in]
+ instructions_inv = [(i,) for i in sorted_irreps.p]
+ self.extr_inv = Extract(sorted_irreps.irreps, irreps_in_list, instructions_inv)
+
+ self.irreps_in = irreps_in
+ self.irreps_out = sorted_irreps.irreps.simplify()
+
+ def forward(self, x):
+ r'''irreps_in -> irreps_out'''
+ extracted = self.extr(x)
+ return torch.cat(extracted, dim=-1)
+
+ def inverse(self, x):
+ r'''irreps_out -> irreps_in'''
+ extracted_inv = self.extr_inv(x)
+ return torch.cat(extracted_inv, dim=-1)
+
+
+
+
+
+class e3LayerNorm(nn.Module):
+ def __init__(self, irreps_in, eps=1e-5, affine=True, normalization='component', subtract_mean=True, divide_norm=False):
+ super().__init__()
+
+ self.irreps_in = Irreps(irreps_in)
+ self.eps = eps
+
+ if affine:
+ ib, iw = 0, 0
+ weight_slices, bias_slices = [], []
+ for mul, ir in irreps_in:
+ if ir.is_scalar(): # bias only to 0e
+ bias_slices.append(slice(ib, ib + mul))
+ ib += mul
+ else:
+ bias_slices.append(None)
+ weight_slices.append(slice(iw, iw + mul))
+ iw += mul
+ self.weight = nn.Parameter(torch.ones([iw]))
+ self.bias = nn.Parameter(torch.zeros([ib]))
+ self.bias_slices = bias_slices
+ self.weight_slices = weight_slices
+ else:
+ self.register_parameter('weight', None)
+ self.register_parameter('bias', None)
+
+ self.subtract_mean = subtract_mean
+ self.divide_norm = divide_norm
+ assert normalization in ['component', 'norm']
+ self.normalization = normalization
+
+ self.reset_parameters()
+
+ def reset_parameters(self):
+ if self.weight is not None:
+ self.weight.data.fill_(1)
+ # nn.init.uniform_(self.weight)
+ if self.bias is not None:
+ self.bias.data.fill_(0)
+ # nn.init.uniform_(self.bias)
+
+ def forward(self, x: torch.Tensor, batch: torch.Tensor = None):
+ # input x must have shape [num_node(edge), dim]
+ # if first dimension of x is node index, then batch should be batch.batch
+ # if first dimension of x is edge index, then batch should be batch.batch[batch.edge_index[0]]
+
+ if batch is None:
+ batch = torch.full([x.shape[0]], 0, dtype=torch.int64)
+
+ # from torch_geometric.nn.norm.LayerNorm
+
+ batch_size = int(batch.max()) + 1
+ batch_degree = degree(batch, batch_size, dtype=torch.int64).clamp_(min=1).to(dtype=x.dtype)
+
+ out = []
+ ix = 0
+ for index, (mul, ir) in enumerate(self.irreps_in):
+ field = x[:, ix: ix + mul * ir.dim].reshape(-1, mul, ir.dim) # [node, mul, repr]
+
+ # compute and subtract mean
+ if self.subtract_mean or ir.l == 0: # do not subtract mean for l>0 irreps if subtract_mean=False
+ mean = scatter(field, batch, dim=0, dim_size=batch_size,
+ reduce='add').mean(dim=1, keepdim=True) / batch_degree[:, None, None] # scatter_mean does not support complex number
+ field = field - mean[batch]
+
+ # compute and divide norm
+ if self.divide_norm or ir.l == 0: # do not divide norm for l>0 irreps if divide_norm=False
+ norm = scatter(field.abs().pow(2), batch, dim=0, dim_size=batch_size,
+ reduce='mean').mean(dim=[1,2], keepdim=True) # add abs here to deal with complex numbers
+ if self.normalization == 'norm':
+ norm = norm * ir.dim
+ field = field / (norm.sqrt()[batch] + self.eps)
+
+ # affine
+ if self.weight is not None:
+ weight = self.weight[self.weight_slices[index]]
+ field = field * weight[None, :, None]
+ if self.bias is not None and ir.is_scalar():
+ bias = self.bias[self.bias_slices[index]]
+ field = field + bias[None, :, None]
+
+ out.append(field.reshape(-1, mul * ir.dim))
+ ix += mul * ir.dim
+
+ out = torch.cat(out, dim=-1)
+
+ return out
+
+class e3ElementWise:
+ def __init__(self, irreps_in):
+ self.irreps_in = Irreps(irreps_in)
+
+ len_weight = 0
+ for mul, ir in self.irreps_in:
+ len_weight += mul
+
+ self.len_weight = len_weight
+
+ def __call__(self, x: torch.Tensor, weight: torch.Tensor):
+ # x should have shape [edge/node, channels]
+ # weight should have shape [edge/node, self.len_weight]
+
+ ix = 0
+ iw = 0
+ out = []
+ for mul, ir in self.irreps_in:
+ field = x[:, ix: ix + mul * ir.dim]
+ field = field.reshape(-1, mul, ir.dim)
+ field = field * weight[:, iw: iw + mul][:, :, None]
+ field = field.reshape(-1, mul * ir.dim)
+
+ ix += mul * ir.dim
+ iw += mul
+ out.append(field)
+
+ return torch.cat(out, dim=-1)
+
+
+class SkipConnection(nn.Module):
+ def __init__(self, irreps_in, irreps_out, is_complex=False):
+ super().__init__()
+ irreps_in = Irreps(irreps_in)
+ irreps_out = Irreps(irreps_out)
+ self.sc = None
+ if irreps_in == irreps_out:
+ self.sc = None
+ else:
+ self.sc = Linear(irreps_in=irreps_in, irreps_out=irreps_out)
+
+ def forward(self, old, new):
+ if self.sc is not None:
+ old = self.sc(old)
+
+ return old + new
+
+
+class SelfTp(nn.Module):
+ def __init__(self, irreps_in, irreps_out, **kwargs):
+ '''z_i = W'_{ij}x_j W''_{ik}x_k (k>=j)'''
+ super().__init__()
+
+ assert not kwargs.pop('internal_weights', False) # internal weights must be True
+ assert kwargs.pop('shared_weights', True) # shared weights must be false
+
+ irreps_in = Irreps(irreps_in)
+ irreps_out = Irreps(irreps_out)
+
+ instr_tp = []
+ weights1, weights2 = [], []
+ for i1, (mul1, ir1) in enumerate(irreps_in):
+ for i2 in range(i1, len(irreps_in)):
+ mul2, ir2 = irreps_in[i2]
+ for i_out, (mul_out, ir3) in enumerate(irreps_out):
+ if ir3 in ir1 * ir2:
+ weights1.append(nn.Parameter(torch.randn(mul1, mul_out)))
+ weights2.append(nn.Parameter(torch.randn(mul2, mul_out)))
+ instr_tp.append((i1, i2, i_out, 'uvw', True, 1.0))
+
+ self.tp = TensorProduct(irreps_in, irreps_in, irreps_out, instr_tp, internal_weights=False, shared_weights=True, **kwargs)
+
+ self.weights1 = nn.ParameterList(weights1)
+ self.weights2 = nn.ParameterList(weights2)
+
+ def forward(self, x):
+ weights = []
+ for weight1, weight2 in zip(self.weights1, self.weights2):
+ weight = weight1[:, None, :] * weight2[None, :, :]
+ weights.append(weight.view(-1))
+ weights = torch.cat(weights)
+ return self.tp(x, x, weights)
+
+@compile_mode("script")
+class SeparateWeightTensorProduct(nn.Module):
+ def __init__(self, irreps_in1: Union[str, o3.Irreps], irreps_in2: Union[str, o3.Irreps], irreps_out: Union[str, o3.Irreps], **kwargs):
+ '''z_i = W'_{ij}x_j W''_{ik}y_k'''
+ super(SeparateWeightTensorProduct, self).__init__()
+
+ assert not kwargs.pop('internal_weights', False) # internal weights must be True
+ assert kwargs.pop('shared_weights', True) # shared weights must be false
+
+ irreps_in1 = Irreps(irreps_in1)
+ irreps_in2 = Irreps(irreps_in2)
+ irreps_out = Irreps(irreps_out)
+ self.irreps_in1 = irreps_in1
+ self.irreps_in2 = irreps_in2
+ self.irreps_out = irreps_out
+
+ instr_tp = []
+ weights1, weights2 = [], []
+ for i1, (mul1, ir1) in enumerate(irreps_in1):
+ for i2, (mul2, ir2) in enumerate(irreps_in2):
+ for i_out, (mul_out, ir3) in enumerate(irreps_out):
+ if ir3 in ir1 * ir2:
+ weights1.append(nn.Parameter(torch.randn(mul1, mul_out)))
+ weights2.append(nn.Parameter(torch.randn(mul2, mul_out)))
+ instr_tp.append((i1, i2, i_out, 'uvw', True, 1.0))
+
+ self.tp = TensorProduct(irreps_in1, irreps_in2, irreps_out, instr_tp, internal_weights=False, shared_weights=True, **kwargs)
+
+ self.weights1 = nn.ParameterList(weights1)
+ self.weights2 = nn.ParameterList(weights2)
+
+ def forward(self, x1: torch.Tensor, x2: torch.Tensor):
+ weights = []
+ for weight1, weight2 in zip(self.weights1, self.weights2):
+ weight = weight1[:, None, :] * weight2[None, :, :]
+ weights.append(weight.view(-1))
+ weights = torch.cat(weights)
+ return self.tp(x1, x2, weights)
+
+
+class SphericalBasis(nn.Module):
+ def __init__(self, target_irreps, rcutoff, eps=1e-7, dtype=torch.get_default_dtype()):
+ super().__init__()
+
+ target_irreps = Irreps(target_irreps)
+
+ self.sh = SphericalHarmonics(
+ irreps_out=target_irreps,
+ normalize=True,
+ normalization='component',
+ )
+
+ max_order = max(map(lambda x: x[1].l, target_irreps)) # maximum angular momentum l
+ max_freq = max(map(lambda x: x[0], target_irreps)) # maximum multiplicity
+
+ basis = bessel_basis(max_order + 1, max_freq)
+ lambdify_torch = {
+ # '+': torch.add,
+ # '-': torch.sub,
+ # '*': torch.mul,
+ # '/': torch.div,
+ # '**': torch.pow,
+ 'sin': torch.sin,
+ 'cos': torch.cos
+ }
+ x = sym.symbols('x')
+ funcs = []
+ for mul, ir in target_irreps:
+ for freq in range(mul):
+ funcs.append(sym.lambdify([x], basis[ir.l][freq], [lambdify_torch]))
+
+ self.bessel_funcs = funcs
+ self.multiplier = e3ElementWise(target_irreps)
+ self.dtype = dtype
+ self.cutoff = polynomial_cutoff
+ self.register_buffer('rcutoff', torch.Tensor([rcutoff]))
+ self.irreps_out = target_irreps
+ self.register_buffer('eps', torch.Tensor([eps]))
+
+ def forward(self, length, direction):
+ # direction should be in y, z, x order
+ sh = self.sh(direction).type(self.dtype)
+ sbf = torch.stack([f((length + self.eps) / self.rcutoff) for f in self.bessel_funcs], dim=-1)
+ return self.multiplier(sh, sbf) * self.cutoff(x=length, r_max=self.rcutoff, p=6).flatten()[:, None]
\ No newline at end of file
diff --git a/dptb/nn/embedding/identity.py b/dptb/nn/embedding/identity.py
new file mode 100644
index 00000000..16a2d076
--- /dev/null
+++ b/dptb/nn/embedding/identity.py
@@ -0,0 +1,24 @@
+import torch
+from typing import Optional, Tuple, Union
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+
+@Embedding.register("none")
+class Identity(torch.nn.Module):
+ def __init__(
+ self,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+ super(Identity, self).__init__(Identity, dtype, device)
+
+ def forward(self, data: AtomicDataDict) -> AtomicDataDict:
+ return data
+
+ @property
+ def out_edge_dim(self):
+ return 0
+
+ @property
+ def out_note_dim(self):
+ return 0
\ No newline at end of file
diff --git a/dptb/nn/embedding/mpnn.py b/dptb/nn/embedding/mpnn.py
new file mode 100644
index 00000000..0628f1b6
--- /dev/null
+++ b/dptb/nn/embedding/mpnn.py
@@ -0,0 +1,316 @@
+from torch_geometric.nn.conv import MessagePassing
+import torch
+from typing import Optional, Tuple, Union
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..base import ResNet, FFN
+from torch.nn import Linear
+import torch.nn as nn
+import torch.nn.functional as F
+from dptb.utils.constants import dtype_dict
+from ..type_encode.one_hot import OneHotAtomEncoding
+from ..cutoff import polynomial_cutoff
+from ..radial_basis import BesselBasis
+from torch_runstats.scatter import scatter
+
+def get_neuron_config(nl):
+ n = len(nl)
+ if n % 2 == 0:
+ d_out = nl[-1]
+ nl = nl[:-1]
+ config = []
+ for i in range(1,len(nl)-1, 2):
+ config.append({'in_features': nl[i-1], 'hidden_features': nl[i], 'out_features': nl[i+1]})
+
+ if n % 2 == 0:
+ config.append({'in_features': nl[-1], 'out_features': d_out})
+
+ return config
+
+@Embedding.register("mpnn")
+class MPNN(torch.nn.Module):
+ def __init__(
+ self,
+ r_max:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_basis: Union[int, torch.LongTensor, None]=None,
+ n_node: Union[int, torch.LongTensor, None]=None,
+ n_edge: Union[int, torch.LongTensor, None]=None,
+ n_atom: int=1,
+ n_layer: int=1,
+ node_net: dict={},
+ edge_net: dict={},
+ if_exp: bool=False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu")):
+
+ super(MPNN, self).__init__()
+
+ self.n_node = n_node
+ self.n_edge = n_edge
+ if isinstance(r_max, float):
+ self.r_max = torch.tensor(r_max, dtype=dtype, device=device)
+ else:
+ self.r_max = r_max
+
+ self.p = p
+ self.layers = torch.nn.ModuleList([])
+ for _ in range(n_layer):
+ self.layers.append(
+ CGConvLayer(
+ r_max=self.r_max,
+ p=p,
+ n_edge=n_edge,
+ n_node=n_node,
+ node_net=node_net,
+ edge_net=edge_net,
+ dtype=dtype,
+ device=device,
+ if_exp=if_exp,
+ )
+ )
+
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+ self.node_emb = torch.nn.Linear(n_atom, n_node)
+ edge_net["config"] = get_neuron_config([2*n_node+n_basis]+edge_net["neurons"]+[n_edge])
+ self.edge_emb = ResNet(**edge_net, device=device, dtype=dtype)
+ self.bessel = BesselBasis(r_max=r_max, num_basis=n_basis, trainable=True)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ data = self.onehot(data)
+ data = AtomicDataDict.with_env_vectors(data, with_lengths=True)
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ node_features = self.node_emb(data[AtomicDataDict.NODE_ATTRS_KEY])
+ env_features = self.edge_emb(torch.cat([node_features[data[AtomicDataDict.ENV_INDEX_KEY][0]], node_features[data[AtomicDataDict.ENV_INDEX_KEY][1]], self.bessel(data[AtomicDataDict.ENV_LENGTH_KEY])], dim=-1))
+ edge_features = self.edge_emb(torch.cat([node_features[data[AtomicDataDict.EDGE_INDEX_KEY][0]], node_features[data[AtomicDataDict.EDGE_INDEX_KEY][1]], self.bessel(data[AtomicDataDict.EDGE_LENGTH_KEY])], dim=-1))
+
+ for layer in self.layers:
+ node_features, env_features, edge_features = layer(
+ env_index=data[AtomicDataDict.ENV_INDEX_KEY],
+ edge_index=data[AtomicDataDict.EDGE_INDEX_KEY],
+ env_emb=env_features,
+ edge_emb=edge_features,
+ node_emb=node_features,
+ env_length=data[AtomicDataDict.ENV_LENGTH_KEY],
+ edge_length=data[AtomicDataDict.EDGE_LENGTH_KEY],
+ )
+ data[AtomicDataDict.NODE_FEATURES_KEY] = node_features
+
+ data[AtomicDataDict.EDGE_FEATURES_KEY] = edge_features
+
+ return data
+
+ @property
+ def out_edge_dim(self):
+ return self.n_edge
+
+ @property
+ def out_node_dim(self):
+ return self.n_node
+
+
+class MPNNLayer(MessagePassing):
+ def __init__(
+ self,
+ r_max:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_edge: int,
+ n_node: int,
+ node_net: dict={},
+ edge_net: dict={},
+ aggr="mean",
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"), **kwargs):
+
+ super(MPNNLayer, self).__init__(aggr=aggr, **kwargs)
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ if isinstance(r_max, float):
+ self.r_max = torch.tensor(r_max, dtype=dtype, device=device)
+ else:
+ self.r_max = r_max
+
+ self.p = p
+
+ edge_net["config"] = get_neuron_config([2*n_node+n_edge]+edge_net["neurons"]+[n_edge])
+ self.mlp_edge = ResNet(**edge_net, device=device, dtype=dtype)
+ node_net["config"] = get_neuron_config([2*n_node+n_edge]+node_net["neurons"]+[n_node])
+ self.mlp_node = ResNet(**node_net, dtype=dtype, device=device)
+
+ self.node_layer_norm = torch.nn.LayerNorm(n_node, elementwise_affine=True)
+
+ self.device = device
+ self.dtype = dtype
+
+ def forward(self, edge_index, env_index, node_emb, env_emb, edge_emb):
+
+ z_ik = torch.cat([node_emb[env_index[0]], node_emb[env_index[1]], env_emb], dim=-1)
+ node_emb = node_emb + self.propagate(env_index, z_ik=z_ik)
+
+ env_emb = self.mlp_edge(torch.cat([node_emb[env_index[0]], env_emb, node_emb[env_index[1]]], dim=-1))
+ edge_emb = self.mlp_edge(torch.cat([node_emb[edge_index[0]], edge_emb, node_emb[edge_index[1]]], dim=-1))
+
+ return node_emb, env_emb, edge_emb
+
+ def message(self, z_ik):
+
+ return self.mlp_node(z_ik)
+
+ def update(self, aggr_out):
+ """_summary_
+
+ Parameters
+ ----------
+ aggr_out : The output of the aggregation layer, which is the mean of the message vectors as size [N, D, 3]
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+
+ aggr_out = aggr_out.reshape(aggr_out.shape[0], -1)
+ return self.node_layer_norm(aggr_out) # [N, D*D]
+
+class CGConvLayer(MessagePassing):
+ def __init__(
+ self,
+ r_max:Union[float, torch.Tensor],
+ p:Union[int, torch.LongTensor],
+ n_edge: int,
+ n_node: int,
+ aggr="add",
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ if_exp: bool=False,
+ **kwargs):
+
+ super(CGConvLayer, self).__init__(aggr=aggr, **kwargs)
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+ if isinstance(r_max, float):
+ self.r_max = torch.tensor(r_max, dtype=dtype, device=device)
+ else:
+ self.r_max = r_max
+
+ self.p = p
+ self.if_exp = if_exp
+
+ self.lin_edge_f = Linear(2*n_node+n_edge, n_edge, device=device, dtype=dtype)
+ self.lin_edge_s = Linear(2*n_node+n_edge, n_edge, device=device, dtype=dtype)
+ self.lin_node_f = Linear(2*n_node+n_edge, n_node, dtype=dtype, device=device)
+ self.lin_node_s = Linear(2*n_node+n_edge, n_node, dtype=dtype, device=device)
+
+ self.node_layer_norm = torch.nn.LayerNorm(n_node, elementwise_affine=True)
+
+ self.device = device
+ self.dtype = dtype
+
+ def forward(self, edge_index, env_index, node_emb, env_emb, edge_emb, env_length, edge_length):
+ z_ik = torch.cat([node_emb[env_index[0]], node_emb[env_index[1]], env_emb], dim=-1)
+ node_emb = node_emb + self.propagate(env_index, z_ik=z_ik, env_length=env_length)
+
+ env_feature_in = torch.cat([node_emb[env_index[0]], env_emb, node_emb[env_index[1]]], dim=-1)
+ env_emb = self.lin_edge_f(env_feature_in).sigmoid() * \
+ F.softplus(self.lin_edge_s(env_feature_in))
+ if self.if_exp:
+ sigma = 3
+ n = 2
+ env_emb = env_emb * torch.exp(-env_length ** n / sigma ** n / 2).view(-1, 1)
+
+ edge_feature_in = torch.cat([node_emb[edge_index[0]], edge_emb, node_emb[edge_index[1]]], dim=-1)
+ edge_emb = self.lin_edge_f(edge_feature_in).sigmoid() * \
+ F.softplus(self.lin_edge_s(edge_feature_in))
+ if self.if_exp:
+ sigma = 3
+ n = 2
+ edge_emb = edge_emb * torch.exp(-edge_length ** n / sigma ** n / 2).view(-1, 1)
+
+ return node_emb, env_emb, edge_emb
+
+
+ def message(self, z_ik, env_length) -> torch.Tensor:
+ out = self.lin_node_f(z_ik).sigmoid() * F.softplus(self.lin_node_s(z_ik))
+ if self.if_exp:
+ sigma = 3
+ n = 2
+ out = out * torch.exp(-env_length ** n / sigma ** n / 2).view(-1, 1)
+ return self.node_layer_norm(out)
+
+
+
+# class CGConv(MessagePassing):
+# def __init__(self, channels: Union[int, Tuple[int, int]], dim: int = 0,
+# aggr: str = 'add', normalization: str = None,
+# bias: bool = True, if_exp: bool = False, **kwargs):
+# super(CGConv, self).__init__(aggr=aggr, flow="source_to_target", **kwargs)
+# self.channels = channels
+# self.dim = dim
+# self.normalization = normalization
+# self.if_exp = if_exp
+
+# if isinstance(channels, int):
+# channels = (channels, channels)
+
+# self.lin_f = nn.Linear(sum(channels) + dim, channels[1], bias=bias)
+# self.lin_s = nn.Linear(sum(channels) + dim, channels[1], bias=bias)
+# if self.normalization == 'BatchNorm':
+# self.bn = nn.BatchNorm1d(channels[1], track_running_stats=True)
+# elif self.normalization == 'LayerNorm':
+# self.ln = LayerNorm(channels[1])
+# elif self.normalization == 'PairNorm':
+# self.pn = PairNorm(channels[1])
+# elif self.normalization == 'InstanceNorm':
+# self.instance_norm = InstanceNorm(channels[1])
+# elif self.normalization is None:
+# pass
+# else:
+# raise ValueError('Unknown normalization function: {}'.format(normalization))
+
+# self.reset_parameters()
+
+# def reset_parameters(self):
+# self.lin_f.reset_parameters()
+# self.lin_s.reset_parameters()
+# if self.normalization == 'BatchNorm':
+# self.bn.reset_parameters()
+
+# def forward(self, x: Union[torch.Tensor, PairTensor], edge_index: Adj,
+# edge_attr: OptTensor, env_index, env_attr, batch, distance, size: Size = None) -> torch.Tensor:
+# """"""
+# if isinstance(x, torch.Tensor):
+# x: PairTensor = (x, x)
+
+# # propagate_type: (x: PairTensor, edge_attr: OptTensor)
+# out = self.propagate(edge_index, x=x, edge_attr=edge_attr, distance=distance, size=size)
+# if self.normalization == 'BatchNorm':
+# out = self.bn(out)
+# elif self.normalization == 'LayerNorm':
+# out = self.ln(out, batch)
+# elif self.normalization == 'PairNorm':
+# out = self.pn(out, batch)
+# elif self.normalization == 'InstanceNorm':
+# out = self.instance_norm(out, batch)
+# out += x[1]
+# return out
+
+# def message(self, x_i, x_j, edge_attr: OptTensor, distance) -> torch.Tensor:
+# z = torch.cat([x_i, x_j, edge_attr], dim=-1)
+# out = self.lin_f(z).sigmoid() * F.softplus(self.lin_s(z))
+# if self.if_exp:
+# sigma = 3
+# n = 2
+# out = out * torch.exp(-distance ** n / sigma ** n / 2).view(-1, 1)
+# return out
+
+# def __repr__(self):
+# return '{}({}, dim={})'.format(self.__class__.__name__, self.channels, self.dim)
\ No newline at end of file
diff --git a/dptb/nn/embedding/se2.py b/dptb/nn/embedding/se2.py
new file mode 100644
index 00000000..6616bb2c
--- /dev/null
+++ b/dptb/nn/embedding/se2.py
@@ -0,0 +1,199 @@
+from torch_geometric.nn import MessagePassing
+from torch_geometric.nn import Aggregation
+import torch
+from typing import Optional, Tuple, Union
+from dptb.data import AtomicDataDict
+from dptb.nn.embedding.emb import Embedding
+from ..base import ResNet
+from dptb.utils.constants import dtype_dict
+from ..type_encode.one_hot import OneHotAtomEncoding
+
+def get_neuron_config(nl):
+ n = len(nl)
+ if n % 2 == 0:
+ d_out = nl[-1]
+ nl = nl[:-1]
+ config = []
+ for i in range(1,len(nl)-1, 2):
+ config.append({'in_features': nl[i-1], 'hidden_features': nl[i], 'out_features': nl[i+1]})
+
+ if n % 2 == 0:
+ config.append({'in_features': nl[-1], 'out_features': d_out})
+
+ return config
+
+@Embedding.register("se2")
+class SE2Descriptor(torch.nn.Module):
+ def __init__(
+ self,
+ rs: Union[float, torch.Tensor],
+ rc:Union[float, torch.Tensor],
+ n_axis: Union[int, torch.LongTensor, None]=None,
+ n_atom: int=1,
+ radial_net: dict={},
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ) -> None:
+ """
+ a demo input
+ se2_config = {
+ "rs": 3.0,
+ "rc": 4.0,
+ "n_axis": 4,
+ "n_atom": 2,
+ "radial_embedding": {
+ "neurons": [10,20,30],
+ "activation": "tanh",
+ "if_batch_normalized": False
+ },
+ "dtype": "float32",
+ "device": "cpu"
+ }
+ """
+
+ super(SE2Descriptor, self).__init__()
+ self.onehot = OneHotAtomEncoding(num_types=n_atom, set_features=False)
+ self.descriptor = _SE2Descriptor(rs=rs, rc=rc, n_atom=n_atom, radial_net=radial_net, n_axis=n_axis, dtype=dtype, device=device)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ """_summary_
+
+ Parameters
+ ----------
+ data : _type_
+ _description_
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+ data = self.onehot(data)
+ data = AtomicDataDict.with_env_vectors(data, with_lengths=True)
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ data[AtomicDataDict.NODE_FEATURES_KEY], data[AtomicDataDict.EDGE_FEATURES_KEY] = self.descriptor(
+ data[AtomicDataDict.ENV_VECTORS_KEY],
+ data[AtomicDataDict.NODE_ATTRS_KEY],
+ data[AtomicDataDict.ENV_INDEX_KEY],
+ data[AtomicDataDict.EDGE_INDEX_KEY],
+ data[AtomicDataDict.EDGE_LENGTH_KEY],
+ )
+
+ return data
+
+ @property
+ def out_edge_dim(self):
+ return self.descriptor.n_out + 1
+
+ @property
+ def out_node_dim(self):
+ return self.descriptor.n_out
+
+
+
+
+class SE2Aggregation(Aggregation):
+ def forward(self, x: torch.Tensor, index: torch.LongTensor, **kwargs):
+ """_summary_
+
+ Parameters
+ ----------
+ x : tensor of size (N, d), where d dimension looks like (emb(s(r)), \hat{x}, \hat{y}, \hat{z})
+ The is the embedding of the env_vectors
+ index : _type_
+ _description_
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+ direct_vec = x[:, -3:]
+ x = x[:,:-3].unsqueeze(-1) * direct_vec.unsqueeze(1) # [N_env, D, 3]
+ return self.reduce(x, index, reduce="mean", dim=0) # [N_atom, D, 3] following the orders of atom index.
+
+
+class _SE2Descriptor(MessagePassing):
+ def __init__(
+ self,
+ rs: Union[float, torch.Tensor],
+ rc:Union[float, torch.Tensor],
+ n_axis: Union[int, torch.LongTensor, None]=None,
+ aggr: SE2Aggregation=SE2Aggregation(),
+ radial_net: dict={},
+ n_atom: int=1,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"), **kwargs):
+
+ super(_SE2Descriptor, self).__init__(aggr=aggr, **kwargs)
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+
+
+ radial_net["config"] = get_neuron_config([2*n_atom+1]+radial_net["neurons"])
+ self.embedding_net = ResNet(**radial_net, device=device, dtype=dtype)
+ if isinstance(rs, float):
+ self.rs = torch.tensor(rs, dtype=dtype, device=device)
+ else:
+ self.rs = rs
+ if isinstance(rc, float):
+ self.rc = torch.tensor(rc, dtype=dtype, device=device)
+ else:
+ self.rc = rc
+
+ assert len(self.rc.flatten()) == 1 and len(self.rs.flatten()) == 1
+ assert self.rs < self.rc
+ self.n_axis = n_axis
+ self.device = device
+ self.dtype = dtype
+ if n_axis == None:
+ self.n_axis = radial_net["neurons"][-1]
+ self.n_out = self.n_axis * radial_net["neurons"][-1]
+
+ def forward(self, env_vectors, atom_attr, env_index, edge_index, edge_length):
+ n_env = env_index.shape[1]
+ env_attr = atom_attr[env_index].transpose(1,0).reshape(n_env,-1)
+ out_node = self.propagate(env_index, env_vectors=env_vectors, env_attr=env_attr) # [N_atom, D, 3]
+ out_edge = self.edge_updater(edge_index, node_descriptor=out_node, edge_length=edge_length) # [N_edge, D*D]
+
+ return out_node, out_edge
+
+ def message(self, env_vectors, env_attr):
+ rij = env_vectors.norm(dim=-1, keepdim=True)
+ snorm = self.smooth(rij, self.rs, self.rc)
+ env_vectors = snorm * env_vectors / rij
+ return torch.cat([self.embedding_net(torch.cat([snorm, env_attr], dim=-1)), env_vectors], dim=-1) # [N_env, D_emb + 3]
+
+ def update(self, aggr_out):
+ """_summary_
+
+ Parameters
+ ----------
+ aggr_out : The output of the aggregation layer, which is the mean of the message vectors as size [N, D, 3]
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+ out = torch.bmm(aggr_out, aggr_out.transpose(1, 2))[:,:,:self.n_axis].flatten(start_dim=1, end_dim=2)
+ out = out - out.mean(1, keepdim=True)
+ out = out / out.norm(dim=1, keepdim=True)
+ return out # [N, D*D]
+
+ def edge_update(self, edge_index, node_descriptor, edge_length):
+ return torch.cat([node_descriptor[edge_index[0]] + node_descriptor[edge_index[1]], 1/edge_length.reshape(-1,1)], dim=-1) # [N_edge, D*D]
+
+ def smooth(self, r: torch.Tensor, rs: torch.Tensor, rc: torch.Tensor):
+ r_ = torch.zeros_like(r)
+ r_[r AtomicDataDict.Type:
+ data = self.h2k(data)
+ if self.overlap:
+ data = self.s2k(data)
+ chklowt = torch.linalg.cholesky(data[self.s_out_field])
+ chklowtinv = torch.linalg.inv(chklowt)
+ Heff = (chklowtinv @ data[self.h_out_field] @ torch.transpose(chklowtinv,dim0=1,dim1=2).conj())
+ else:
+ Heff = data[self.h_out_field]
+
+ data[self.out_field] = torch.linalg.eigvalsh(Heff)
+
+ return data
diff --git a/dptb/nn/graph_mixin.py b/dptb/nn/graph_mixin.py
new file mode 100644
index 00000000..253cba26
--- /dev/null
+++ b/dptb/nn/graph_mixin.py
@@ -0,0 +1,119 @@
+import random
+from typing import Dict, Tuple, Callable, Any, Sequence, Union, Mapping, Optional
+from collections import OrderedDict
+
+import torch
+
+from e3nn import o3
+
+from dptb.data import AtomicDataDict
+from dptb.utils import instantiate
+
+
+class GraphModuleMixin:
+ r"""Mixin parent class for ``torch.nn.Module``s that act on and return ``AtomicDataDict.Type`` graph data.
+
+ All such classes should call ``_init_irreps`` in their ``__init__`` functions with information on the data fields they expect, require, and produce, as well as their corresponding irreps.
+ """
+
+ def _init_irreps(
+ self,
+ irreps_in: Dict[str, Any] = {},
+ my_irreps_in: Dict[str, Any] = {},
+ required_irreps_in: Sequence[str] = [],
+ irreps_out: Dict[str, Any] = {},
+ ):
+ """Setup the expected data fields and their irreps for this graph module.
+
+ ``None`` is a valid irreps in the context for anything that is invariant but not well described by an ``e3nn.o3.Irreps``. An example are edge indexes in a graph, which are invariant but are integers, not ``0e`` scalars.
+
+ Args:
+ irreps_in (dict): maps names of all input fields from previous modules or
+ data to their corresponding irreps
+ my_irreps_in (dict): maps names of fields to the irreps they must have for
+ this graph module. Will be checked for consistancy with ``irreps_in``
+ required_irreps_in: sequence of names of fields that must be present in
+ ``irreps_in``, but that can have any irreps.
+ irreps_out (dict): mapping names of fields that are modified/output by
+ this graph module to their irreps.
+ """
+ # Coerce
+ irreps_in = {} if irreps_in is None else irreps_in
+ irreps_in = AtomicDataDict._fix_irreps_dict(irreps_in)
+ # positions are *always* 1o, and always present
+ if AtomicDataDict.POSITIONS_KEY in irreps_in:
+ if irreps_in[AtomicDataDict.POSITIONS_KEY] != o3.Irreps("1x1o"):
+ raise ValueError(
+ f"Positions must have irreps 1o, got instead `{irreps_in[AtomicDataDict.POSITIONS_KEY]}`"
+ )
+ irreps_in[AtomicDataDict.POSITIONS_KEY] = o3.Irreps("1o")
+ # edges are also always present
+ if AtomicDataDict.EDGE_INDEX_KEY in irreps_in:
+ if irreps_in[AtomicDataDict.EDGE_INDEX_KEY] is not None:
+ raise ValueError(
+ f"Edge indexes must have irreps None, got instead `{irreps_in[AtomicDataDict.EDGE_INDEX_KEY]}`"
+ )
+ irreps_in[AtomicDataDict.EDGE_INDEX_KEY] = None
+
+ my_irreps_in = AtomicDataDict._fix_irreps_dict(my_irreps_in)
+
+ irreps_out = AtomicDataDict._fix_irreps_dict(irreps_out)
+ # Confirm compatibility:
+ # with my_irreps_in
+ for k in my_irreps_in:
+ if k in irreps_in and irreps_in[k] != my_irreps_in[k]:
+ raise ValueError(
+ f"The given input irreps {irreps_in[k]} for field '{k}' is incompatible with this configuration {type(self)}; should have been {my_irreps_in[k]}"
+ )
+ # with required_irreps_in
+ for k in required_irreps_in:
+ if k not in irreps_in:
+ raise ValueError(
+ f"This {type(self)} requires field '{k}' to be in irreps_in"
+ )
+ # Save stuff
+ self.irreps_in = irreps_in
+ # The output irreps of any graph module are whatever inputs it has, overwritten with whatever outputs it has.
+ new_out = irreps_in.copy()
+ new_out.update(irreps_out)
+ self.irreps_out = new_out
+
+ def _add_independent_irreps(self, irreps: Dict[str, Any]):
+ """
+ Insert some independent irreps that need to be exposed to the self.irreps_in and self.irreps_out.
+ The terms that have already appeared in the irreps_in will be removed.
+
+ Args:
+ irreps (dict): maps names of all new fields
+ """
+
+ irreps = {
+ key: irrep for key, irrep in irreps.items() if key not in self.irreps_in
+ }
+ irreps_in = AtomicDataDict._fix_irreps_dict(irreps)
+ irreps_out = AtomicDataDict._fix_irreps_dict(
+ {key: irrep for key, irrep in irreps.items() if key not in self.irreps_out}
+ )
+ self.irreps_in.update(irreps_in)
+ self.irreps_out.update(irreps_out)
+
+ def _make_tracing_inputs(self, n):
+ # We impliment this to be able to trace graph modules
+ out = []
+ for _ in range(n):
+ batch = random.randint(1, 4)
+ # TODO: handle None case
+ # TODO: do only required inputs
+ # TODO: dummy input if empty?
+ out.append(
+ {
+ "forward": (
+ {
+ k: i.randn(batch, -1)
+ for k, i in self.irreps_in.items()
+ if i is not None
+ },
+ )
+ }
+ )
+ return out
\ No newline at end of file
diff --git a/dptb/nn/hamiltonian.py b/dptb/nn/hamiltonian.py
new file mode 100644
index 00000000..8693a22b
--- /dev/null
+++ b/dptb/nn/hamiltonian.py
@@ -0,0 +1,394 @@
+"""
+This file refactor the SK and E3 Rotation in dptb/hamiltonian/transform_se3.py], it will take input of AtomicDataDict.Type
+perform rotation from irreducible matrix element / sk parameters in EDGE/NODE FEATURE, and output the atomwise/ pairwise hamiltonian
+as the new EDGE/NODE FEATURE. The rotation should also be a GNN module and speed uptable by JIT. The HR2HK should also be included here.
+The indexmapping should ne passed here.
+"""
+
+import torch
+from e3nn.o3 import wigner_3j, Irrep, xyz_to_angles, Irrep
+from dptb.utils.constants import h_all_types, anglrMId
+from typing import Tuple, Union, Dict
+from dptb.data.transforms import OrbitalMapper
+from dptb.data import AtomicDataDict
+import re
+from torch_runstats.scatter import scatter
+
+#TODO: 1. jit acceleration 2. GPU support 3. rotate AB and BA bond together.
+
+# The `E3Hamiltonian` class is a PyTorch module that represents a Hamiltonian for a system with a
+# given basis and can perform forward computations on input data.
+
+class E3Hamiltonian(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ decompose: bool = False,
+ edge_field: str = AtomicDataDict.EDGE_FEATURES_KEY,
+ node_field: str = AtomicDataDict.NODE_FEATURES_KEY,
+ overlap: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ) -> None:
+
+ super(E3Hamiltonian, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ if isinstance(device, str):
+ device = torch.device(device)
+ self.overlap = overlap
+ self.dtype = dtype
+ self.device = device
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb")
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.cgbasis = {}
+ self.decompose = decompose
+ self.edge_field = edge_field
+ self.node_field = node_field
+
+ # initialize the CG basis
+ self.idp.get_orbpairtype_maps()
+ orbpairtypes = self.idp.orbpairtype_maps.keys()
+ for orbpair in orbpairtypes:
+ self._initialize_CG_basis(orbpair)
+
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ """
+ The forward function takes in atomic data and performs computations on the edge and node features
+ based on the decompose flag. It performs the following operations:
+ decompose = True:
+ - the function will read the EDGE and NODE features and take them as hamiltonian blocks, the
+ block will be decomposed into reduced matrix element that is irrelevant to the direction.
+ decompose = False:
+ - the function will read the EDGE and NODE features and take them as reduced matrix element, the
+ function will transform the reduced matrix element into hamiltonian blocks with directional dependence.
+
+ :param data: The `data` parameter is a dictionary that contains atomic data. It has the following
+ keys:
+ :type data: AtomicDataDict.Type
+ :return: the updated `data` dictionary.
+ """
+
+ assert data[self.edge_field].shape[1] == self.idp.reduced_matrix_element
+ if not self.overlap:
+ assert data[self.node_field].shape[1] == self.idp.reduced_matrix_element
+
+ n_edge = data[AtomicDataDict.EDGE_INDEX_KEY].shape[1]
+ n_node = data[AtomicDataDict.NODE_FEATURES_KEY].shape[0]
+
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ if not self.decompose:
+ # The EDGE_FEATURES_KEY and NODE_FAETURE_KEY are the reduced matrix elements
+
+ # compute hopping blocks
+ for opairtype in self.idp.orbpairtype_maps.keys():
+ # currently, "a-b" and "b-a" orbital pair are computed seperately, it is able to combined further
+ # for better performance
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+ n_rme = (2*l1+1) * (2*l2+1) # number of reduced matrix element
+ rme = data[self.edge_field][:, self.idp.orbpairtype_maps[opairtype]]
+ rme = rme.reshape(n_edge, -1, n_rme)
+ rme = rme.transpose(1,2) # shape (N, n_rme, n_pair)
+
+ HR = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ rme[:,None, None, :, :], dim=-2) # shape (N, 2l1+1, 2l2+1, n_pair)
+
+ # rotation
+ # angle = xyz_to_angles(data[AtomicDataDict.EDGE_VECTORS_KEY][:,[1,2,0]]) # (tensor(N), tensor(N))
+ # rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=self.dtype, device=self.device)) # tensor(N, 2l1+1, 2l1+1)
+ # rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=self.dtype, device=self.device)) # tensor(N, 2l2+1, 2l2+1)
+ # HR = torch.einsum("nlm, nmoq, nko -> nqlk", rot_mat_L, H_z, rot_mat_R).reshape(n_edge, -1) # shape (N, n_pair * n_rme)
+ HR = HR.permute(0,3,1,2).reshape(n_edge, -1)
+ data[self.edge_field][:, self.idp.orbpairtype_maps[opairtype]] = HR
+
+ # compute onsite blocks
+ if not self.overlap:
+ for opairtype in self.idp.orbpairtype_maps.keys():
+ # currently, "a-b" and "b-a" orbital pair are computed seperately, it is able to combined further
+ # for better performance
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+
+ n_rme = (2*l1+1) * (2*l2+1) # number of reduced matrix element
+ rme = data[self.node_field][:, self.idp.orbpairtype_maps[opairtype]]
+ rme = rme.reshape(n_node, -1, n_rme)
+ rme = rme.transpose(1,2) # shape (N, n_rme, n_pair)
+
+ HR = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ rme[:,None, None, :, :], dim=-2) # shape (N, 2l1+1, 2l2+1, n_pair)
+ HR = HR.permute(0,3,1,2).reshape(n_node, -1)
+
+ # the onsite block does not have rotation
+ data[self.node_field][:, self.idp.orbpairtype_maps[opairtype]] = HR
+
+ else:
+ for opairtype in self.idp.orbpairtype_maps.keys():
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+ nL, nR = 2*l1+1, 2*l2+1
+ HR = data[self.edge_field][:, self.idp.orbpairtype_maps[opairtype]]
+ HR = HR.reshape(n_edge, -1, nL, nR) # shape (N, n_pair, nL, nR)
+
+ # rotation
+ # angle = xyz_to_angles(data[AtomicDataDict.EDGE_VECTORS_KEY][:,[1,2,0]]) # (tensor(N), tensor(N))
+ # rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=self.dtype, device=self.device)) # tensor(N, 2l1+1, 2l1+1)
+ # rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=self.dtype, device=self.device)) # tensor(N, 2l2+1, 2l2+1)
+ # H_z = torch.einsum("nml, nqmo, nok -> nlkq", rot_mat_L, HR, rot_mat_R) # shape (N, nL, nR, n_pair)
+
+ HR = HR.permute(0,2,3,1) # shape (N, nL, nR, n_pair)
+ rme = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ HR[:,:,:,None,:], dim=(1,2)) # shape (N, n_rme, n_pair)
+ rme = rme.transpose(1,2).reshape(n_edge, -1)
+
+ data[self.edge_field][:, self.idp.orbpairtype_maps[opairtype]] = rme
+
+ if not self.overlap:
+ for opairtype in self.idp.orbpairtype_maps.keys():
+ # currently, "a-b" and "b-a" orbital pair are computed seperately, it is able to combined further
+ # for better performance
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+ nL, nR = 2*l1+1, 2*l2+1 # number of reduced matrix element
+ HR = data[self.node_field][:, self.idp.orbpairtype_maps[opairtype]]
+ HR = HR.reshape(n_node, -1, nL, nR).permute(0,2,3,1)# shape (N, nL, nR, n_pair)
+
+ rme = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ HR[:,:,:,None,:], dim=(1,2)) # shape (N, n_rme, n_pair)
+ rme = rme.transpose(1,2).reshape(n_node, -1)
+
+ # the onsite block doesnot have rotation
+ data[self.node_field][:, self.idp.orbpairtype_maps[opairtype]] = rme
+
+ return data
+
+ def _initialize_CG_basis(self, pairtype: str):
+ """
+ The function initializes a Clebsch-Gordan basis for a given pair type.
+
+ :param pairtype: The parameter "pairtype" is a string that represents a pair of angular momentum
+ quantum numbers. It is expected to have a length of 3, where the first and third characters
+ represent the angular momentum quantum numbers of two particles, and the second character
+ represents the type of interaction between the particles
+ :type pairtype: str
+ :return: the CG basis, which is a tensor containing the Clebsch-Gordan coefficients for the given
+ pairtype.
+ """
+ self.cgbasis.setdefault(pairtype, None)
+
+ l1, l2 = anglrMId[pairtype[0]], anglrMId[pairtype[2]]
+
+ cg = []
+ for l_ird in range(abs(l2-l1), l2+l1+1):
+ cg.append(wigner_3j(int(l1), int(l2), int(l_ird), dtype=self.dtype, device=self.device) * (2*l_ird+1)**0.5)
+
+ cg = torch.cat(cg, dim=-1)
+ self.cgbasis[pairtype] = cg
+
+ return cg
+
+
+class SKHamiltonian(torch.nn.Module):
+ # transform SK parameters to SK hamiltonian with E3 CG basis, strain is included.
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp_sk: Union[OrbitalMapper, None]=None,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ edge_field: str = AtomicDataDict.EDGE_FEATURES_KEY,
+ node_field: str = AtomicDataDict.NODE_FEATURES_KEY,
+ onsite: bool = False,
+ strain: bool = False,
+ **kwargs,
+ ) -> None:
+ super(SKHamiltonian, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ if isinstance(device, str):
+ device = torch.device(device)
+ self.dtype = dtype
+ self.device = device
+ self.onsite = onsite
+
+ if basis is not None:
+ self.idp_sk = OrbitalMapper(basis, method="sktb", device=device)
+ if idp_sk is not None:
+ assert idp_sk.basis == self.idp_sk.basis, "The basis of idp and basis should be the same."
+ else:
+ assert idp_sk is not None, "Either basis or idp should be provided."
+ self.idp_sk = idp_sk
+ # initilize a e3 indexmapping to help putting the orbital wise blocks into atom-pair wise format
+ self.idp = OrbitalMapper(self.idp_sk.basis, method="e3tb", device=device)
+ self.basis = self.idp.basis
+ self.cgbasis = {}
+ self.strain = strain
+ self.edge_field = edge_field
+ self.node_field = node_field
+
+ self.idp_sk.get_orbpair_maps()
+ self.idp_sk.get_skonsite_maps()
+ self.idp.get_orbpair_maps()
+
+ pairtypes = self.idp_sk.orbpairtype_maps.keys()
+ for pairtype in pairtypes:
+ self._initialize_CG_basis(pairtype)
+
+ self.sk2irs = {
+ 's-s': torch.tensor([[1.]], dtype=self.dtype, device=self.device),
+ 's-p': torch.tensor([[1.]], dtype=self.dtype, device=self.device),
+ 's-d': torch.tensor([[1.]], dtype=self.dtype, device=self.device),
+ 'p-s': torch.tensor([[1.]], dtype=self.dtype, device=self.device),
+ 'p-p': torch.tensor([
+ [3**0.5/3,2/3*3**0.5],[6**0.5/3,-6**0.5/3]
+ ], dtype=self.dtype, device=self.device
+ ),
+ 'p-d':torch.tensor([
+ [(2/5)**0.5,(6/5)**0.5],[(3/5)**0.5,-2/5**0.5]
+ ], dtype=self.dtype, device=self.device
+ ),
+ 'd-s':torch.tensor([[1.]], dtype=self.dtype, device=self.device),
+ 'd-p':torch.tensor([
+ [(2/5)**0.5,(6/5)**0.5],
+ [(3/5)**0.5,-2/5**0.5]
+ ], dtype=self.dtype, device=self.device
+ ),
+ 'd-d':torch.tensor([
+ [5**0.5/5, 2*5**0.5/5, 2*5**0.5/5],
+ [2*(1/14)**0.5,2*(1/14)**0.5,-4*(1/14)**0.5],
+ [3*(2/35)**0.5,-4*(2/35)**0.5,(2/35)**0.5]
+ ], dtype=self.dtype, device=self.device
+ )
+ }
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ # transform sk parameters to irreducible matrix element
+
+ assert data[self.edge_field].shape[1] == self.idp_sk.reduced_matrix_element
+ if self.onsite:
+ assert data[self.node_field].shape[1] == self.idp_sk.n_onsite_Es
+ n_node = data[self.node_field].shape[0]
+
+ n_edge = data[self.edge_field].shape[0]
+
+
+ edge_features = data[self.edge_field].clone()
+ data[self.edge_field] = torch.zeros((n_edge, self.idp.reduced_matrix_element), dtype=self.dtype, device=self.device)
+
+ # for hopping blocks
+ for opairtype in self.idp_sk.orbpairtype_maps.keys():
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+ n_skp = min(l1, l2)+1 # number of reduced matrix element
+ skparam = edge_features[:, self.idp_sk.orbpairtype_maps[opairtype]].reshape(n_edge, -1, n_skp)
+ rme = skparam @ self.sk2irs[opairtype].T # shape (N, n_pair, n_rme)
+ rme = rme.transpose(1,2) # shape (N, n_rme, n_pair)
+
+ H_z = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ rme[:,None, None, :, :], dim=-2) # shape (N, 2l1+1, 2l2+1, n_pair)
+
+ # rotation
+ # when get the angle, the xyz vector should be transformed to yzx.
+ angle = xyz_to_angles(data[AtomicDataDict.EDGE_VECTORS_KEY][:,[1,2,0]]) # (tensor(N), tensor(N))
+ # The roataion matrix is SO3 rotation, therefore Irreps(l,1), is used here.
+ rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0].cpu(), angle[1].cpu(), torch.tensor(0., dtype=self.dtype)).to(self.device) # tensor(N, 2l1+1, 2l1+1)
+ rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0].cpu(), angle[1].cpu(), torch.tensor(0., dtype=self.dtype)).to(self.device) # tensor(N, 2l2+1, 2l2+1)
+
+ # Here The string to control einsum is important, the order of the index should be the same as the order of the tensor
+ # H_z = torch.einsum("nlm, nmoq, nko -> nqlk", rot_mat_L, H_z, rot_mat_R) # shape (N, n_pair, 2l1+1, 2l2+1)
+ HR = torch.einsum("nlm, nmoq, nko -> nqlk", rot_mat_L, H_z, rot_mat_R).reshape(n_edge, -1) # shape (N, n_pair * 2l2+1 * 2l2+1)
+
+ if l1 < l2:
+ HR = HR * (-1)**(l1+l2)
+
+ data[self.edge_field][:, self.idp.orbpairtype_maps[opairtype]] = HR
+
+ # compute onsite blocks
+ if self.onsite:
+ node_feature = data[self.node_field].clone()
+ data[self.node_field] = torch.zeros(n_node, self.idp.reduced_matrix_element, dtype=self.dtype, device=self.device)
+
+ for otype in self.idp_sk.skonsite_maps.keys():
+ # currently, "a-b" and "b-a" orbital pair are computed seperately, it is able to combined further
+ # for better performance
+
+ l = anglrMId[re.findall(r"[a-z]", otype)[0]]
+
+ skparam = node_feature[:, self.idp_sk.skonsite_maps[otype]].reshape(n_node, -1, 1)
+ HR = torch.eye(2*l+1, dtype=self.dtype, device=self.device)[None, None, :, :] * skparam[:,:, None, :] # shape (N, n_pair, 2l1+1, 2l2+1)
+ # the onsite block doesnot have rotation
+
+ data[self.node_field][:, self.idp.orbpair_maps[otype+"-"+otype]] = HR.reshape(n_node, -1)
+
+ # compute if strain effect is included
+ # this is a little wired operation, since it acting on somekind of a edge(strain env) feature, and summed up to return a node feature.
+ if self.strain:
+ n_onsitenv = len(data[AtomicDataDict.ONSITENV_FEATURES_KEY])
+ for opairtype in self.idp.orbpairtype_maps.keys(): # save all env direction and pair direction like sp and ps, but only get sp
+ l1, l2 = anglrMId[opairtype[0]], anglrMId[opairtype[2]]
+ # opairtype = opair[1]+"-"+opair[4]
+ n_skp = min(l1, l2)+1 # number of reduced matrix element
+ skparam = data[AtomicDataDict.ONSITENV_FEATURES_KEY][:, self.idp_sk.orbpairtype_maps[opairtype]].reshape(n_onsitenv, -1, n_skp)
+ rme = skparam @ self.sk2irs[opairtype].T # shape (N, n_pair, n_rme)
+ rme = rme.transpose(1,2) # shape (N, n_rme, n_pair)
+
+ H_z = torch.sum(self.cgbasis[opairtype][None,:,:,:,None] * \
+ rme[:,None, None, :, :], dim=-2) # shape (N, 2l1+1, 2l2+1, n_pair)
+
+ angle = xyz_to_angles(data[AtomicDataDict.ONSITENV_VECTORS_KEY][:,[1,2,0]]) # (tensor(N), tensor(N))
+ rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0].cpu(), angle[1].cpu(), torch.tensor(0., dtype=self.dtype)).to(self.device) # tensor(N, 2l1+1, 2l1+1)
+ rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0].cpu(), angle[1].cpu(), torch.tensor(0., dtype=self.dtype)).to(self.device) # tensor(N, 2l2+1, 2l2+1)
+
+ HR = torch.einsum("nlm, nmoq, nko -> nqlk", rot_mat_L, H_z, rot_mat_R) # shape (N, n_pair, 2l1+1, 2l2+1)
+
+ HR = scatter(src=HR, index=data[AtomicDataDict.ONSITENV_INDEX_KEY][0], dim=0, reduce="sum") # shape (n_node, n_pair, 2l1+1, 2l2+1)
+ # A-B o1-o2 (A-B o2-o1)= (B-A o1-o2)
+
+ data[self.node_field][:, self.idp.orbpairtype_maps[opairtype]] += HR.flatten(1, len(HR.shape)-1) # the index type [node/pair] should align with the index of for loop
+
+ return data
+
+ def _initialize_CG_basis(self, pairtype: str):
+ """
+ The function initializes a Clebsch-Gordan basis for a given pair type.
+
+ :param pairtype: The parameter "pairtype" is a string that represents a pair of angular momentum
+ quantum numbers. It is expected to have a length of 3, where the first and third characters
+ represent the angular momentum quantum numbers of two particles, and the second character
+ represents the type of interaction between the particles
+ :type pairtype: str
+ :return: the CG basis, which is a tensor containing the Clebsch-Gordan coefficients for the given
+ pairtype.
+ """
+ self.cgbasis.setdefault(pairtype, None)
+
+ irs_index = {
+ 's-s': [0],
+ 's-p': [1],
+ 's-d': [2],
+ 'p-s': [1],
+ 'p-p': [0,6],
+ 'p-d': [1,11],
+ 'd-s': [2],
+ 'd-p': [1,11],
+ 'd-d': [0,6,20]
+ }
+
+ l1, l2 = anglrMId[pairtype[0]], anglrMId[pairtype[2]]
+
+ cg = []
+ for l_ird in range(abs(l2-l1), l2+l1+1):
+ cg.append(wigner_3j(int(l1), int(l2), int(l_ird), dtype=self.dtype, device=self.device) * (2*l_ird+1)**0.5)
+
+ cg = torch.cat(cg, dim=-1)[:,:,irs_index[pairtype]]
+ self.cgbasis[pairtype] = cg
+
+ return cg
\ No newline at end of file
diff --git a/dptb/nn/hr2hk.py b/dptb/nn/hr2hk.py
new file mode 100644
index 00000000..3dfb7ad3
--- /dev/null
+++ b/dptb/nn/hr2hk.py
@@ -0,0 +1,120 @@
+import torch
+from dptb.utils.constants import h_all_types, anglrMId, atomic_num_dict, atomic_num_dict_r
+from typing import Tuple, Union, Dict
+from dptb.data.transforms import OrbitalMapper
+from dptb.data import AtomicDataDict
+import re
+
+class HR2HK(torch.nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ edge_field: str = AtomicDataDict.EDGE_FEATURES_KEY,
+ node_field: str = AtomicDataDict.NODE_FEATURES_KEY,
+ out_field: str = AtomicDataDict.HAMILTONIAN_KEY,
+ overlap: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ):
+ super(HR2HK, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+ self.overlap = overlap
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb", device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ assert idp.method == "e3tb", "The method of idp should be e3tb."
+ self.idp = idp
+
+ self.basis = self.idp.basis
+ self.idp.get_orbpair_maps()
+
+ self.edge_field = edge_field
+ self.node_field = node_field
+ self.out_field = out_field
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+
+ # construct bond wise hamiltonian block from obital pair wise node/edge features
+ # we assume the edge feature have the similar format as the node feature, which is reduced from orbitals index oj-oi with j>i
+
+ orbpair_hopping = data[self.edge_field]
+ orbpair_onsite = data.get(self.node_field)
+ bondwise_hopping = torch.zeros((len(orbpair_hopping), self.idp.full_basis_norb, self.idp.full_basis_norb), dtype=self.dtype, device=self.device)
+ bondwise_hopping.to(self.device)
+ bondwise_hopping.type(self.dtype)
+ onsite_block = torch.zeros((len(data[AtomicDataDict.ATOM_TYPE_KEY]), self.idp.full_basis_norb, self.idp.full_basis_norb,), dtype=self.dtype, device=self.device)
+
+ ist = 0
+ for i,iorb in enumerate(self.idp.full_basis):
+ jst = 0
+ li = anglrMId[re.findall(r"[a-zA-Z]+", iorb)[0]]
+ for j,jorb in enumerate(self.idp.full_basis):
+ orbpair = iorb + "-" + jorb
+ lj = anglrMId[re.findall(r"[a-zA-Z]+", jorb)[0]]
+
+ # constructing hopping blocks
+ if iorb == jorb:
+ factor = 0.5
+ else:
+ factor = 1.0
+
+ if i <= j:
+ bondwise_hopping[:,ist:ist+2*li+1,jst:jst+2*lj+1] = factor * orbpair_hopping[:,self.idp.orbpair_maps[orbpair]].reshape(-1, 2*li+1, 2*lj+1)
+
+
+ # constructing onsite blocks
+ if self.overlap:
+ if iorb == jorb:
+ onsite_block[:, ist:ist+2*li+1, jst:jst+2*lj+1] = factor * torch.eye(2*li+1, dtype=self.dtype, device=self.device).reshape(1, 2*li+1, 2*lj+1).repeat(onsite_block.shape[0], 1, 1)
+ else:
+ if i <= j:
+ onsite_block[:,ist:ist+2*li+1,jst:jst+2*lj+1] = factor * orbpair_onsite[:,self.idp.orbpair_maps[orbpair]].reshape(-1, 2*li+1, 2*lj+1)
+
+ jst += 2*lj+1
+ ist += 2*li+1
+ self.onsite_block = onsite_block
+ self.bondwise_hopping = bondwise_hopping
+
+
+ # R2K procedure can be done for all kpoint at once.
+ all_norb = self.idp.atom_norb[data[AtomicDataDict.ATOM_TYPE_KEY]].sum()
+ block = torch.zeros(data[AtomicDataDict.KPOINT_KEY].shape[0], all_norb, all_norb, dtype=self.dtype, device=self.device)
+ block = torch.complex(block, torch.zeros_like(block))
+
+ atom_id_to_indices = {}
+ ist = 0
+ for i, oblock in enumerate(onsite_block):
+ mask = self.idp.mask_to_basis[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[i]]
+ masked_oblock = oblock[mask][:,mask]
+ block[:,ist:ist+masked_oblock.shape[0],ist:ist+masked_oblock.shape[1]] = masked_oblock.squeeze(0)
+ atom_id_to_indices[i] = slice(ist, ist+masked_oblock.shape[0])
+ ist += masked_oblock.shape[0]
+
+ for i, hblock in enumerate(bondwise_hopping):
+ iatom = data[AtomicDataDict.EDGE_INDEX_KEY][0][i]
+ jatom = data[AtomicDataDict.EDGE_INDEX_KEY][1][i]
+ iatom_indices = atom_id_to_indices[int(iatom)]
+ jatom_indices = atom_id_to_indices[int(jatom)]
+ imask = self.idp.mask_to_basis[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[iatom]]
+ jmask = self.idp.mask_to_basis[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()[jatom]]
+ masked_hblock = hblock[imask][:,jmask]
+
+ block[:,iatom_indices,jatom_indices] += masked_hblock.squeeze(0).type_as(block) * \
+ torch.exp(-1j * 2 * torch.pi * (data[AtomicDataDict.KPOINT_KEY] @ data[AtomicDataDict.EDGE_CELL_SHIFT_KEY][i])).reshape(-1,1,1)
+
+ block = block + block.transpose(1,2).conj()
+ block = block.contiguous()
+
+ data[self.out_field] = block
+
+ return data
+
\ No newline at end of file
diff --git a/dptb/nn/nnsk.py b/dptb/nn/nnsk.py
new file mode 100644
index 00000000..4617ce0f
--- /dev/null
+++ b/dptb/nn/nnsk.py
@@ -0,0 +1,548 @@
+"""The file doing the process from the fitting net output sk formula parameters in node/edge feature to the tight binding two centre integrals parameters in node/edge feature.
+in: Data
+out Data
+
+basically a map from a matrix parameters to edge/node features, or strain mode's environment edge features
+"""
+
+import torch
+from dptb.utils.constants import h_all_types, anglrMId
+from typing import Tuple, Union, Dict
+from dptb.data.transforms import OrbitalMapper
+from dptb.data import AtomicDataDict
+import numpy as np
+import torch.nn as nn
+from .sktb import OnsiteFormula, bond_length_list, HoppingFormula
+from dptb.utils.constants import atomic_num_dict_r, atomic_num_dict
+from dptb.nn.hamiltonian import SKHamiltonian
+from dptb.utils.tools import j_loader
+
+class NNSK(torch.nn.Module):
+ name = "nnsk"
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp_sk: Union[OrbitalMapper, None]=None,
+ onsite: Dict={"method": "none"},
+ hopping: Dict={"method": "powerlaw", "rs":6.0, "w": 0.2},
+ overlap: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ transform: bool = True,
+ freeze: bool = False,
+ push: Dict=None,
+ std: float = 0.01,
+ **kwargs,
+ ) -> None:
+
+ super(NNSK, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ self.dtype = dtype
+ self.device = device
+
+ if basis is not None:
+ self.idp_sk = OrbitalMapper(basis, method="sktb", device=self.device)
+ if idp_sk is not None:
+ assert idp_sk.basis == self.idp_sk.basis, "The basis of idp and basis should be the same."
+ else:
+ assert idp_sk is not None, "Either basis or idp should be provided."
+ self.idp_sk = idp_sk
+
+ self.transform = transform
+ self.basis = self.idp_sk.basis
+ self.idp_sk.get_orbpair_maps()
+ self.idp_sk.get_skonsite_maps()
+ self.onsite_options = onsite
+ self.hopping_options = hopping
+ self.push = push
+ self.model_options = {
+ "nnsk":{
+ "onsite": onsite,
+ "hopping": hopping,
+ "freeze": freeze,
+ "push": push,
+ }
+ }
+
+ self.count_push = 0
+
+ # init_onsite, hopping, overlap formula
+
+ self.onsite_fn = OnsiteFormula(idp=self.idp_sk, functype=self.onsite_options["method"], dtype=dtype, device=device)
+ self.hopping_fn = HoppingFormula(functype=self.hopping_options["method"])
+ if overlap:
+ self.overlap_fn = HoppingFormula(functype=self.hopping_options["method"], overlap=True)
+
+ # init_param
+ #
+ hopping_param = torch.empty([len(self.idp_sk.bond_types), self.idp_sk.reduced_matrix_element, self.hopping_fn.num_paras], dtype=self.dtype, device=self.device)
+ nn.init.normal_(hopping_param, mean=0.0, std=std)
+ self.hopping_param = torch.nn.Parameter(hopping_param)
+ if overlap:
+ overlap_param = torch.empty([len(self.idp_sk.bond_types), self.idp_sk.reduced_matrix_element, self.hopping_fn.num_paras], dtype=self.dtype, device=self.device)
+ nn.init.normal_(overlap_param, mean=0.0, std=std)
+ self.overlap_param = torch.nn.Parameter(overlap_param)
+
+ if self.onsite_options["method"] == "strain":
+ self.onsite_param = None
+ elif self.onsite_options["method"] == "none":
+ self.onsite_param = None
+ elif self.onsite_options["method"] in ["NRL", "uniform"]:
+ onsite_param = torch.empty([len(self.idp_sk.type_names), self.idp_sk.n_onsite_Es, self.onsite_fn.num_paras], dtype=self.dtype, device=self.device)
+ nn.init.normal_(onsite_param, mean=0.0, std=std)
+ self.onsite_param = torch.nn.Parameter(onsite_param)
+ else:
+ raise NotImplementedError(f"The onsite method {self.onsite_options['method']} is not implemented.")
+
+ if self.onsite_options["method"] == "strain":
+ # AB [ss, sp, sd, ps, pp, pd, ds, dp, dd]
+ # AA [...]
+ # but need to map to all pairs and all orbital pairs like AB, AA, BB, BA for [ss, sp, sd, ps, pp, pd, ds, dp, dd]
+ # with this map: BA[sp, sd] = AB[ps, ds]
+ strain_param = torch.empty([len(self.idp_sk.bond_types), self.idp_sk.reduced_matrix_element, self.hopping_fn.num_paras], dtype=self.dtype, device=self.device)
+ nn.init.normal_(strain_param, mean=0.0, std=std)
+ self.strain_param = torch.nn.Parameter(strain_param)
+ # symmetrize the env for same atomic spices
+
+ self.hamiltonian = SKHamiltonian(idp_sk=self.idp_sk, onsite=True, dtype=self.dtype, device=self.device, strain=hasattr(self, "strain_param"))
+ if overlap:
+ self.overlap = SKHamiltonian(idp_sk=self.idp_sk, onsite=False, edge_field=AtomicDataDict.EDGE_OVERLAP_KEY, node_field=AtomicDataDict.NODE_OVERLAP_KEY, dtype=self.dtype, device=self.device)
+ self.idp = self.hamiltonian.idp
+
+ if freeze:
+ for (name, param) in self.named_parameters():
+ param.requires_grad = False
+
+ def push_decay(self, rs_thr: float=0., rc_thr: float=0., w_thr: float=0., period:int=100):
+ """Push the soft cutoff function
+
+ Parameters
+ ----------
+ rs_thr : float
+ the threshold step to push the rs
+ w_thr : float
+ the threshold step to push the w
+ """
+
+
+ if self.count_push // period > 0:
+ if abs(rs_thr) > 0:
+ self.hopping_options["rs"] += rs_thr
+ if abs(w_thr) > 0:
+ self.hopping_options["w"] += w_thr
+ if abs(rc_thr) > 0:
+ self.hopping_options["rc"] += rc_thr
+
+ self.model_options["nnsk"]["hopping"] = self.hopping_options
+
+ self.count_push = 0
+ else:
+ self.count_push += 1
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ # get the env and bond from the data
+ # calculate the sk integrals
+ # calculate the onsite
+ # calculate the hopping
+ # calculate the overlap
+ # return the data with updated edge/node features
+
+ # map the parameters to the edge/node/env features
+
+ # compute integrals from parameters using hopping and onsite clas
+
+ # symmetrize the bond for same atomic spices
+ # reflect_keys = np.array(list(self.idp_sk.pair_maps.keys()), dtype="str").reshape(len(self.idp_sk.full_basis), len(self.idp_sk.full_basis)).transpose(1,0).reshape(-1)
+ # params = 0.5 * self.hopping_param.data[self.idp_sk.transform_reduced_bond(torch.tensor(list(self.idp_sk._valid_set)), torch.tensor(list(self.idp_sk._valid_set)))]
+ # reflect_params = torch.zeros_like(params)
+ # for k, k_r in zip(self.idp_sk.pair_maps.keys(), reflect_keys):
+ # reflect_params[:,self.idp_sk.pair_maps[k],:] += params[:,self.idp_sk.pair_maps[k_r],:]
+ # self.hopping_param.data[self.idp_sk.transform_reduced_bond(torch.tensor(list(self.idp_sk._valid_set)), torch.tensor(list(self.idp_sk._valid_set)))] = \
+ # reflect_params + params
+
+ # if hasattr(self, "overlap"):
+ # params = 0.5 * self.overlap_param.data[self.idp_sk.transform_reduced_bond(torch.tensor(list(self.idp_sk._valid_set)), torch.tensor(list(self.idp_sk._valid_set)))]
+ # reflect_params = torch.zeros_like(params)
+ # for k, k_r in zip(self.idp_sk.pair_maps.keys(), reflect_keys):
+ # reflect_params[:,self.idp_sk.pair_maps[k],:] += params[:,self.idp_sk.pair_maps[k_r],:]
+ # self.overlap_param.data[self.idp_sk.transform_reduced_bond(torch.tensor(list(self.idp_sk._valid_set)), torch.tensor(list(self.idp_sk._valid_set)))] = \
+ # reflect_params + params
+
+ # # in strain case, all env pair need to be symmetrized
+ # if self.onsite_fn.functype == "strain":
+ # params = 0.5 * self.strain_param.data
+ # reflect_params = torch.zeros_like(params)
+ # for k, k_r in zip(self.idp_sk.pair_maps.keys(), reflect_keys):
+ # reflect_params[:,self.idp_sk.pair_maps[k],:] += params[:,self.idp_sk.pair_maps[k_r],:]
+ # self.strain_param.data = reflect_params + params
+
+ if self.push is not None:
+ if abs(self.push.get("rs_thr")) + abs(self.push.get("rc_thr")) + abs(self.push.get("w_thr")) > 0:
+ self.push_decay(**self.push)
+
+ reflective_bonds = np.array([self.idp_sk.bond_to_type["-".join(self.idp_sk.type_to_bond[i].split("-")[::-1])] for i in range(len(self.idp_sk.bond_types))])
+ params = self.hopping_param.data
+ reflect_params = params[reflective_bonds]
+ for k in self.idp_sk.orbpair_maps.keys():
+ iorb, jorb = k.split("-")
+ if iorb == jorb:
+ # This is to keep the symmetry of the hopping parameters for the same orbital pairs
+ # As-Bs = Bs-As; we need to do this because for different orbital pairs, we only have one set of parameters,
+ # eg. we only have As-Bp and Bs-Ap, but not Ap-Bs and Bp-As; and we will use Ap-Bs = Bs-Ap and Bp-As = As-Bp to calculate the hopping integral
+ self.hopping_param.data[:,self.idp_sk.orbpair_maps[k],:] = 0.5 * (params[:,self.idp_sk.orbpair_maps[k],:] + reflect_params[:,self.idp_sk.orbpair_maps[k],:])
+ if hasattr(self, "overlap"):
+ params = self.overlap_param.data
+ reflect_params = params[reflective_bonds]
+ for k in self.idp_sk.orbpair_maps.keys():
+ iorb, jorb = k.split("-")
+ if iorb == jorb:
+ self.overlap_param.data[:,self.idp_sk.orbpair_maps[k],:] = 0.5 * (params[:,self.idp_sk.orbpair_maps[k],:] + reflect_params[:,self.idp_sk.orbpair_maps[k],:])
+
+
+ data = AtomicDataDict.with_edge_vectors(data, with_lengths=True)
+
+ # edge_number = data[AtomicDataDict.ATOMIC_NUMBERS_KEY][data[AtomicDataDict.EDGE_INDEX_KEY]].reshape(2, -1)
+ # edge_index = self.idp_sk.transform_reduced_bond(*edge_number)
+ edge_index = data[AtomicDataDict.EDGE_TYPE_KEY].flatten() # it is bond_type index, transform it to reduced bond index
+ edge_number = self.idp_sk.untransform_bond(edge_index).T
+ edge_index = self.idp_sk.transform_bond(*edge_number)
+
+ # the edge number is the atomic number of the two atoms in the bond.
+ # The bond length list is actually the nucli radius (unit of angstrom) at the atomic number.
+ # now this bond length list is only available for the first 83 elements.
+ assert (edge_number <= 83).all(), "The bond length list is only available for the first 83 elements."
+
+ r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[edge_number-1].sum(0)
+
+ data[AtomicDataDict.EDGE_FEATURES_KEY] = self.hopping_fn.get_skhij(
+ rij=data[AtomicDataDict.EDGE_LENGTH_KEY],
+ paraArray=self.hopping_param[edge_index], # [N_edge, n_pairs, n_paras],
+ **self.hopping_options,
+ r0=r0
+ ) # [N_edge, n_pairs]
+
+ if hasattr(self, "overlap"):
+ equal_orbpair = torch.zeros(self.idp_sk.reduced_matrix_element, dtype=self.dtype, device=self.device)
+ for orbpair_key, slices in self.idp_sk.orbpair_maps.items():
+ if orbpair_key.split("-")[0] == orbpair_key.split("-")[1]:
+ equal_orbpair[slices] = 1.0
+ # this paraconst is to make sure the overlap between the same orbital pairs of the save atom is 1.0
+ # this is taken from the formula of NRL-TB.
+ # the overlap tag now is only designed to be used in the NRL-TB case. In the future, we may need to change this.
+ paraconst = edge_number[0].eq(edge_number[1]).float().view(-1, 1) * equal_orbpair.unsqueeze(0)
+
+ data[AtomicDataDict.EDGE_OVERLAP_KEY] = self.overlap_fn.get_sksij(
+ rij=data[AtomicDataDict.EDGE_LENGTH_KEY],
+ paraArray=self.overlap_param[edge_index],
+ paraconst=paraconst,
+ **self.hopping_options,
+ r0=r0,
+ )
+
+ atomic_numbers = self.idp_sk.untransform_atom(data[AtomicDataDict.ATOM_TYPE_KEY].flatten())
+ if self.onsite_fn.functype == "NRL":
+ data = AtomicDataDict.with_env_vectors(data, with_lengths=True)
+ data[AtomicDataDict.NODE_FEATURES_KEY] = self.onsite_fn.get_skEs(
+ # atomic_numbers=data[AtomicDataDict.ATOMIC_NUMBERS_KEY],
+ atomic_numbers=atomic_numbers,
+ onsitenv_index=data[AtomicDataDict.ONSITENV_INDEX_KEY],
+ onsitenv_length=data[AtomicDataDict.ONSITENV_LENGTH_KEY],
+ nn_onsite_paras=self.onsite_param,
+ **self.onsite_options,
+ )
+ else:
+ data[AtomicDataDict.NODE_FEATURES_KEY] = self.onsite_fn.get_skEs(
+ atomic_numbers=atomic_numbers,
+ nn_onsite_paras=self.onsite_param
+ )
+
+ # if hasattr(self, "overlap"):
+ # data[AtomicDataDict.NODE_OVERLAP_KEY] = torch.ones_like(data[AtomicDataDict.NODE_OVERLAP_KEY])
+
+ # compute strain
+ if self.onsite_fn.functype == "strain":
+ data = AtomicDataDict.with_onsitenv_vectors(data, with_lengths=True)
+ onsitenv_number = self.idp_sk.untransform_atom(data[AtomicDataDict.ATOM_TYPE_KEY].flatten())[data[AtomicDataDict.ONSITENV_INDEX_KEY]].reshape(2, -1)
+ onsitenv_index = self.idp_sk.transform_bond(*onsitenv_number)
+ # reflect_index = self.idp_sk.transform_bond(*onsitenv_number.flip(0))
+ # onsitenv_index[onsitenv_index<0] = reflect_index[onsitenv_index<0] + len(self.idp_sk.reduced_bond_types)
+ # reflect_params = torch.zeros_like(self.strain_param)
+ # for k, k_r in zip(self.idp_sk.pair_maps.keys(), reflect_keys):
+ # reflect_params[:,self.idp_sk.pair_maps[k],:] += self.strain_param[:,self.idp_sk.pair_maps[k_r],:]
+ # onsitenv_params = torch.cat([self.strain_param,
+ # reflect_params], dim=0)
+
+ r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[onsitenv_number-1].sum(0)
+ assert (edge_number <= 83).all(), "The bond length list is only available for the first 83 elements."
+ onsitenv_params = self.hopping_fn.get_skhij(
+ rij=data[AtomicDataDict.ONSITENV_LENGTH_KEY],
+ paraArray=self.strain_param[onsitenv_index], # [N_edge, n_pairs, n_paras],
+ r0=r0,
+ **self.onsite_options,
+ ) # [N_edge, n_pairs]
+
+ data[AtomicDataDict.ONSITENV_FEATURES_KEY] = onsitenv_params
+
+ # sk param to hamiltonian and overlap
+ if self.transform:
+ data = self.hamiltonian(data)
+ if hasattr(self, "overlap"):
+ data = self.overlap(data)
+
+ return data
+
+ @classmethod
+ def from_reference(
+ cls,
+ checkpoint: str,
+ basis: Dict[str, Union[str, list]]=None,
+ onsite: Dict=None,
+ hopping: Dict=None,
+ overlap: bool=None,
+ dtype: Union[str, torch.dtype]=None,
+ device: Union[str, torch.device]=None,
+ push: Dict=None,
+ freeze: bool = None,
+ std: float = 0.01,
+ **kwargs,
+ ):
+ # the mapping from the parameters of the ref_model and the current model can be found using
+ # reference model's idp and current idp
+
+ common_options = {
+ "dtype": dtype,
+ "device": device,
+ "basis": basis,
+ "overlap": overlap,
+ }
+
+ nnsk = {
+ "onsite": onsite,
+ "hopping": hopping,
+ "freeze": freeze,
+ "push": push,
+ "std": std
+ }
+
+
+ if checkpoint.split(".")[-1] == "json":
+ for k,v in common_options.items():
+ assert v is not None, f"You need to provide {k} when you are initializing a model from a json file."
+ for k,v in nnsk.items():
+ assert v is not None, f"You need to provide {k} when you are initializing a model from a json file."
+
+ v1_model = j_loader(checkpoint)
+ model = cls._from_model_v1(
+ v1_model=v1_model,
+ **nnsk,
+ **common_options,
+ )
+
+ del v1_model
+
+ else:
+ f = torch.load(checkpoint, map_location=device)
+ for k,v in common_options.items():
+ if v is None:
+ common_options[k] = f["config"]["common_options"][k]
+ for k,v in nnsk.items():
+ if v is None:
+ nnsk[k] = f["config"]["model_options"]["nnsk"][k]
+
+ model = cls(**common_options, **nnsk)
+
+ if f["config"]["common_options"]["basis"] == common_options["basis"] and \
+ f["config"]["model_options"] == model.model_options:
+ model.load_state_dict(f["model_state_dict"])
+ else:
+ #TODO: handle the situation when ref_model config is not the same as the current model
+ # load hopping
+ ref_idp = OrbitalMapper(f["config"]["common_options"]["basis"], method="sktb")
+ idp = OrbitalMapper(common_options["basis"], method="sktb")
+
+ ref_idp.get_orbpair_maps()
+ idp.get_orbpair_maps()
+
+
+ params = f["model_state_dict"]["hopping_param"]
+ for bond in ref_idp.bond_types:
+ if bond in idp.bond_types:
+ iasym, jasym = bond.split("-")
+ for ref_forbpair in ref_idp.orbpair_maps.keys():
+ rfiorb, rfjorb = ref_forbpair.split("-")
+ riorb, rjorb = ref_idp.full_basis_to_basis[iasym][rfiorb], ref_idp.full_basis_to_basis[jasym][rfjorb]
+ fiorb, fjorb = idp.basis_to_full_basis[iasym].get(riorb), idp.basis_to_full_basis[jasym].get(rjorb)
+ if fiorb is not None and fjorb is not None:
+ sli = idp.orbpair_maps.get(f"{fiorb}-{fjorb}")
+ b = bond
+ if sli is None:
+ sli = idp.orbpair_maps.get(f"{fjorb}-{fiorb}")
+ b = f"{jasym}-{iasym}"
+ model.hopping_param.data[idp.bond_to_type[b],sli] = \
+ params[ref_idp.bond_to_type[b],ref_idp.orbpair_maps[ref_forbpair]]
+
+ # load overlap
+ if hasattr(model, "overlap_param") and f["model_state_dict"].get("overlap_param") != None:
+ params = f["model_state_dict"]["overlap_param"]
+ for bond in ref_idp.bond_types:
+ if bond in idp.bond_types:
+ iasym, jasym = bond.split("-")
+ for ref_forbpair in ref_idp.orbpair_maps.keys():
+ rfiorb, rfjorb = ref_forbpair.split("-")
+ riorb, rjorb = ref_idp.full_basis_to_basis[iasym][rfiorb], ref_idp.full_basis_to_basis[jasym][rfjorb]
+ fiorb, fjorb = idp.basis_to_full_basis[iasym].get(riorb), idp.basis_to_full_basis[jasym].get(rjorb)
+ if fiorb is not None and fjorb is not None:
+ sli = idp.orbpair_maps.get(f"{fiorb}-{fjorb}")
+ b = bond
+ if sli is None:
+ sli = idp.orbpair_maps.get(f"{fjorb}-{fiorb}")
+ b = f"{jasym}-{iasym}"
+ model.overlap_param.data[idp.bond_to_type[b],sli] = \
+ params[ref_idp.bond_to_type[b],ref_idp.orbpair_maps[ref_forbpair]]
+
+ # load onsite
+ if model.onsite_param != None and f["model_state_dict"].get("onsite_param") != None:
+ params = f["model_state_dict"]["onsite_param"]
+ ref_idp.get_skonsite_maps()
+ idp.get_skonsite_maps()
+ for asym in ref_idp.type_names:
+ if asym in idp.type_names:
+ for ref_forb in ref_idp.skonsite_maps.keys():
+ rorb = ref_idp.full_basis_to_basis[asym][ref_forb]
+ forb = idp.basis_to_full_basis[asym].get(rorb)
+ if forb is not None:
+ model.onsite_param.data[idp.chemical_symbol_to_type[asym],idp.skonsite_maps[forb]] = \
+ params[ref_idp.chemical_symbol_to_type[asym],ref_idp.skonsite_maps[ref_forb]]
+
+ # load strain
+ if hasattr(model, "strain_param") and f["model_state_dict"].get("strain_param") != None:
+ params = f["model_state_dict"]["strain_param"]
+ for bond in ref_idp.bond_types:
+ if bond in idp.bond_types:
+ iasym, jasym = bond.split("-")
+ for ref_forbpair in ref_idp.orbpair_maps.keys():
+ rfiorb, rfjorb = ref_forbpair.split("-")
+ riorb, rjorb = ref_idp.full_basis_to_basis[iasym][rfiorb], ref_idp.full_basis_to_basis[jasym][rfjorb]
+ fiorb, fjorb = idp.basis_to_full_basis[iasym].get(riorb), idp.basis_to_full_basis[jasym].get(rjorb)
+ if fiorb is not None and fjorb is not None:
+ sli = idp.orbpair_maps.get(f"{fiorb}-{fjorb}")
+ b = bond
+ if sli is None:
+ sli = idp.orbpair_maps.get(f"{fjorb}-{fiorb}")
+ b = f"{jasym}-{iasym}"
+ model.strain_param.data[idp.bond_to_type[b], sli] = \
+ params[ref_idp.bond_to_type[b],ref_idp.orbpair_maps[ref_forbpair]]
+
+ del f
+
+ if freeze:
+ for (name, param) in model.named_parameters():
+ param.requires_grad = False
+ else:
+ param.requires_grad = True # in case initilizing some frozen checkpoint while with current freeze setted as False
+
+ return model
+
+ @classmethod
+ def _from_model_v1(
+ cls,
+ v1_model: dict,
+ basis: Dict[str, Union[str, list]]=None,
+ idp_sk: Union[OrbitalMapper, None]=None,
+ onsite: Dict={"method": "none"},
+ hopping: Dict={"method": "powerlaw", "rs":6.0, "w": 0.2},
+ overlap: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ std: float = 0.01,
+ ):
+ # could support json file and .pth file checkpoint of nnsk
+
+ if isinstance(dtype, str):
+ dtype = getattr(torch, dtype)
+ dtype = dtype
+ device = device
+
+ if basis is not None:
+ assert idp_sk is None
+ idp_sk = OrbitalMapper(basis, method="sktb")
+ else:
+ assert idp_sk is not None
+
+
+ basis = idp_sk.basis
+ idp_sk.get_orbpair_maps()
+ idp_sk.get_skonsite_maps()
+
+ nnsk_model = cls(basis=basis, idp_sk=idp_sk, dtype=dtype, device=device, onsite=onsite, hopping=hopping, overlap=overlap, std=std)
+
+ onsite_param = v1_model["onsite"]
+ hopping_param = v1_model["hopping"]
+
+ assert len(hopping) > 0, "The hopping parameters should be provided."
+
+ # load hopping params
+ for orbpair, skparam in hopping_param.items():
+ skparam = torch.tensor(skparam, dtype=dtype, device=device)
+ skparam[0] *= 13.605662285137 * 2
+ iasym, jasym, iorb, jorb, num = list(orbpair.split("-"))
+ num = int(num)
+ ian, jan = torch.tensor(atomic_num_dict[iasym]), torch.tensor(atomic_num_dict[jasym])
+ fiorb, fjorb = idp_sk.basis_to_full_basis[iasym][iorb], idp_sk.basis_to_full_basis[jasym][jorb]
+
+
+ if idp_sk.full_basis.index(fiorb) <= idp_sk.full_basis.index(fjorb):
+ nline = idp_sk.transform_bond(iatomic_numbers=ian, jatomic_numbers=jan)
+ nidx = idp_sk.orbpair_maps[f"{fiorb}-{fjorb}"].start + num
+ else:
+ nline = idp_sk.transform_bond(iatomic_numbers=jan, jatomic_numbers=ian)
+ nidx = idp_sk.orbpair_maps[f"{fjorb}-{fiorb}"].start + num
+
+ nnsk_model.hopping_param.data[nline, nidx] = skparam
+ if ian != jan and fiorb == fjorb:
+ nline = idp_sk.transform_bond(iatomic_numbers=jan, jatomic_numbers=ian)
+ nnsk_model.hopping_param.data[nline, nidx] = skparam
+
+ # load onsite params, differently with onsite mode
+ if onsite["method"] == "strain":
+ for orbpair, skparam in onsite_param.items():
+ skparam = torch.tensor(skparam, dtype=dtype, device=device)
+ skparam[0] *= 13.605662285137 * 2
+ iasym, jasym, iorb, jorb, num = list(orbpair.split("-"))
+ num = int(num)
+ ian, jan = torch.tensor(atomic_num_dict[iasym]), torch.tensor(atomic_num_dict[jasym])
+
+ fiorb, fjorb = idp_sk.basis_to_full_basis[iasym][iorb], idp_sk.basis_to_full_basis[iasym][jorb]
+
+ nline = idp_sk.transform_bond(iatomic_numbers=ian, jatomic_numbers=jan)
+ if idp_sk.full_basis.index(fiorb) <= idp_sk.full_basis.index(fjorb):
+ nidx = idp_sk.orbpair_maps[f"{fiorb}-{fjorb}"].start + num
+ else:
+ nidx = idp_sk.orbpair_maps[f"{fjorb}-{fiorb}"].start + num
+
+ nnsk_model.strain_param.data[nline, nidx] = skparam
+
+ # if ian == jan:
+ # nidx = idp_sk.pair_maps[f"{fjorb}-{fiorb}"].start + num
+ # nnsk_model.strain_param.data[nline, nidx] = skparam
+
+ elif onsite["method"] == "none":
+ pass
+ else:
+ for orbon, skparam in onsite_param.items():
+ skparam = torch.tensor(skparam, dtype=dtype, device=device)
+ skparam *= 13.605662285137 * 2
+ iasym, iorb, num = list(orbon.split("-"))
+ num = int(num)
+ ian = torch.tensor(atomic_num_dict[iasym])
+ fiorb = idp_sk.basis_to_full_basis[iasym][iorb]
+
+ nline = idp_sk.transform_atom(atomic_numbers=ian)
+ nidx = idp_sk.skonsite_maps[fiorb].start + num
+
+ nnsk_model.onsite_param.data[nline, nidx] = skparam
+
+ return nnsk_model
+
diff --git a/dptb/nn/norm.py b/dptb/nn/norm.py
new file mode 100644
index 00000000..2f22af10
--- /dev/null
+++ b/dptb/nn/norm.py
@@ -0,0 +1,181 @@
+import torch
+from torch import nn
+
+from e3nn import o3
+from e3nn.util.jit import compile_mode
+from torch_scatter import scatter_mean
+
+@compile_mode("unsupported")
+class TypeNorm(nn.Module):
+ """Batch normalization for orthonormal representations
+
+ It normalizes by the norm of the representations.
+ Note that the norm is invariant only for orthonormal representations.
+ Irreducible representations `wigner_D` are orthonormal.
+
+ Parameters
+ ----------
+ irreps : `o3.Irreps`
+ representation
+
+ eps : float
+ avoid division by zero when we normalize by the variance
+
+ momentum : float
+ momentum of the running average
+
+ affine : bool
+ do we have weight and bias parameters
+
+ reduce : {'mean', 'max'}
+ method used to reduce
+
+ """
+
+ def __init__(self, irreps, eps=1e-5, momentum=0.1, affine=True, num_type=1, reduce="mean", normalization="component"):
+ super().__init__()
+
+ self.irreps = o3.Irreps(irreps)
+ self.eps = eps
+ self.momentum = momentum
+ self.affine = affine
+ self.num_type = num_type
+
+ num_scalar = sum(mul for mul, ir in self.irreps if ir.is_scalar())
+ num_features = self.irreps.num_irreps
+
+ self.register_buffer("running_mean", torch.zeros(num_type, num_scalar))
+ self.register_buffer("running_var", torch.ones(num_type, num_features))
+
+ if affine:
+ self.weight = nn.Parameter(torch.ones(num_type, num_features))
+ self.bias = nn.Parameter(torch.zeros(num_type, num_scalar))
+ else:
+ self.register_parameter("weight", None)
+ self.register_parameter("bias", None)
+
+ assert isinstance(reduce, str), "reduce should be passed as a string value"
+ assert reduce in ["mean", "max"], "reduce needs to be 'mean' or 'max'"
+ self.reduce = reduce
+
+ assert normalization in ["norm", "component"], "normalization needs to be 'norm' or 'component'"
+ self.normalization = normalization
+
+ def __repr__(self):
+ return f"{self.__class__.__name__} ({self.irreps}, eps={self.eps}, momentum={self.momentum})"
+
+ def _roll_avg(self, curr, update):
+ mask = (update.norm(dim=-1) > 1e-7)
+ out = curr.clone()
+ out[mask] = (1 - self.momentum) * curr[mask] + self.momentum * update[mask].detach()
+ return out
+
+
+ def forward(self, input, input_type):
+ """evaluate
+
+ Parameters
+ ----------
+ input : `torch.Tensor`
+ tensor of shape ``(batch, ..., irreps.dim)``
+ input_type : `torch.Tensor`
+ tensor of shape ``(batch)``
+
+ Returns
+ -------
+ `torch.Tensor`
+ tensor of shape ``(batch, ..., irreps.dim)``
+ """
+
+ batch, *size, dim = input.shape
+ input = input.reshape(batch, -1, dim) # [batch, sample, stacked features]
+
+ if self.training:
+ new_means = []
+ new_vars = []
+
+ fields = []
+ ix = 0
+ irm = 0
+ irv = 0
+ iw = 0
+ ib = 0
+
+ for mul, ir in self.irreps:
+ d = ir.dim
+ field = input[:, :, ix : ix + mul * d] # [batch, sample, mul * repr]
+ ix += mul * d
+
+ # [batch, sample, mul, repr]
+ field = field.reshape(batch, -1, mul, d)
+
+ if ir.is_scalar(): # scalars
+ if self.training:
+ field_mean = field.mean(1).reshape(batch, mul) # [batch, mul]
+ field_mean = scatter_mean(field_mean, input_type, dim=0, dim_size=self.num_type) # [num_type, mul]
+ new_means.append(self._roll_avg(self.running_mean[:, irm : irm + mul], field_mean))
+ else:
+ field_mean = self.running_mean[:, irm : irm + mul]
+ irm += mul
+
+ # [batch, sample, mul, repr]
+ field = field - field_mean.reshape(-1, 1, mul, 1)[input_type]
+
+ if self.training:
+ if self.normalization == "norm":
+ field_norm = field.pow(2).sum(3) # [batch, sample, mul]
+ elif self.normalization == "component":
+ field_norm = field.pow(2).mean(3) # [batch, sample, mul]
+ else:
+ raise ValueError("Invalid normalization option {}".format(self.normalization))
+
+ if self.reduce == "mean":
+ field_norm = field_norm.mean(1) # [batch, mul]
+ elif self.reduce == "max":
+ field_norm = field_norm.max(1).values # [batch, mul]
+ else:
+ raise ValueError("Invalid reduce option {}".format(self.reduce))
+
+ field_norm = scatter_mean(field_norm, input_type, dim=0, dim_size=self.num_type) # [num_type, mul]
+ new_vars.append(self._roll_avg(self.running_var[:, irv : irv + mul], field_norm))
+ else:
+ field_norm = self.running_var[:, irv : irv + mul]
+ irv += mul
+
+ field_norm = (field_norm + self.eps).pow(-0.5) # [(batch,) mul]
+
+ if self.affine:
+ weight = self.weight[:, iw : iw + mul] # [mul]
+ iw += mul
+
+ field_norm = field_norm * weight # [num_type, mul]
+
+ field = field * field_norm.reshape(-1, 1, mul, 1)[input_type] # [batch, sample, mul, repr]
+
+ if self.affine and ir.is_scalar(): # scalars
+ bias = self.bias[:, ib : ib + mul] # [mul]
+ ib += mul
+ field += bias.reshape(-1, 1, mul, 1)[input_type] # [batch, sample, mul, repr]
+
+ fields.append(field.reshape(batch, -1, mul * d)) # [batch, sample, mul * repr]
+
+ if ix != dim:
+ fmt = "`ix` should have reached input.size(-1) ({}), but it ended at {}"
+ msg = fmt.format(dim, ix)
+ raise AssertionError(msg)
+
+ if self.training:
+ assert irm == self.running_mean.size(-1)
+ assert irv == self.running_var.size(-1)
+ if self.affine:
+ assert iw == self.weight.size(-1)
+ assert ib == self.bias.size(-1)
+
+ if self.training:
+ if len(new_means) > 0:
+ torch.cat(new_means, dim=-1, out=self.running_mean)
+ if len(new_vars) > 0:
+ torch.cat(new_vars, dim=-1, out=self.running_var)
+
+ output = torch.cat(fields, dim=2) # [batch, sample, stacked features]
+ return output.reshape(batch, *size, dim)
\ No newline at end of file
diff --git a/dptb/nn/radial_basis.py b/dptb/nn/radial_basis.py
new file mode 100644
index 00000000..9278ce08
--- /dev/null
+++ b/dptb/nn/radial_basis.py
@@ -0,0 +1,140 @@
+from typing import Optional
+import math
+
+import torch
+
+from torch import nn
+
+from e3nn.math import soft_one_hot_linspace
+from e3nn.util.jit import compile_mode
+
+
+@compile_mode("trace")
+class e3nn_basis(nn.Module):
+ r_max: float
+ r_min: float
+ e3nn_basis_name: str
+ num_basis: int
+
+ def __init__(
+ self,
+ r_max: float,
+ r_min: Optional[float] = None,
+ e3nn_basis_name: str = "gaussian",
+ num_basis: int = 8,
+ ):
+ super().__init__()
+ self.r_max = r_max
+ self.r_min = r_min if r_min is not None else 0.0
+ self.e3nn_basis_name = e3nn_basis_name
+ self.num_basis = num_basis
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return soft_one_hot_linspace(
+ x,
+ start=self.r_min,
+ end=self.r_max,
+ number=self.num_basis,
+ basis=self.e3nn_basis_name,
+ cutoff=True,
+ )
+
+ def _make_tracing_inputs(self, n: int):
+ return [{"forward": (torch.randn(5, 1),)} for _ in range(n)]
+
+
+class BesselBasis(nn.Module):
+ r_max: float
+ prefactor: float
+
+ def __init__(self, r_max, num_basis=8, trainable=True):
+ r"""Radial Bessel Basis, as proposed in DimeNet: https://arxiv.org/abs/2003.03123
+
+
+ Parameters
+ ----------
+ r_max : float
+ Cutoff radius
+
+ num_basis : int
+ Number of Bessel Basis functions
+
+ trainable : bool
+ Train the :math:`n \pi` part or not.
+ """
+ super(BesselBasis, self).__init__()
+
+ self.trainable = trainable
+ self.num_basis = num_basis
+
+ self.r_max = float(r_max)
+ self.prefactor = 2.0 / self.r_max
+
+ bessel_weights = (
+ torch.linspace(start=1.0, end=num_basis, steps=num_basis) * math.pi
+ )
+ if self.trainable:
+ self.bessel_weights = nn.Parameter(bessel_weights)
+ else:
+ self.register_buffer("bessel_weights", bessel_weights)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Evaluate Bessel Basis for input x.
+
+ Parameters
+ ----------
+ x : torch.Tensor
+ Input
+ """
+ numerator = torch.sin(self.bessel_weights * x.unsqueeze(-1) / self.r_max)
+
+ return self.prefactor * (numerator / x.unsqueeze(-1))
+
+
+def gaussian_smearing(distances, offset, widths, centered=False):
+ if not centered:
+ # compute width of Gaussian functions (using an overlap of 1 STDDEV)
+ coeff = -0.5 / torch.pow(widths, 2)
+ # Use advanced indexing to compute the individual components
+ diff = distances[..., None] - offset
+ else:
+ # if Gaussian functions are centered, use offsets to compute widths
+ coeff = -0.5 / torch.pow(offset, 2)
+ # if Gaussian functions are centered, no offset is subtracted
+ diff = distances[..., None]
+ # compute smear distance values
+ gauss = torch.exp(coeff * torch.pow(diff, 2))
+ return gauss
+
+
+class GaussianBasis(nn.Module):
+ def __init__(
+ self, start=0.0, stop=5.0, n_gaussians=50, centered=False, trainable=False
+ ):
+ super(GaussianBasis, self).__init__()
+ # compute offset and width of Gaussian functions
+ offset = torch.linspace(start, stop, n_gaussians)
+ widths = torch.Tensor((offset[1] - offset[0]) * torch.ones_like(offset)) # FloatTensor
+ if trainable:
+ self.width = nn.Parameter(widths)
+ self.offsets = nn.Parameter(offset)
+ else:
+ self.register_buffer("width", widths)
+ self.register_buffer("offsets", offset)
+ self.centered = centered
+
+ def forward(self, distances):
+ """Compute smeared-gaussian distance values.
+
+ Args:
+ distances (torch.Tensor): interatomic distance values of
+ (N_b x N_at x N_nbh) shape.
+
+ Returns:
+ torch.Tensor: layer output of (N_b x N_at x N_nbh x N_g) shape.
+
+ """
+ return gaussian_smearing(
+ distances, self.offsets, self.width, centered=self.centered
+ )
diff --git a/dptb/nn/rescale.py b/dptb/nn/rescale.py
new file mode 100644
index 00000000..168e8351
--- /dev/null
+++ b/dptb/nn/rescale.py
@@ -0,0 +1,526 @@
+import math
+import torch
+from torch_runstats.scatter import scatter
+from dptb.data import _keys
+import logging
+from typing import Optional, List, Union
+import torch.nn.functional
+from e3nn.o3 import Linear
+from e3nn.util.jit import compile_mode
+from dptb.data import AtomicDataDict
+import e3nn.o3 as o3
+
+class PerSpeciesScaleShift(torch.nn.Module):
+ """Scale and/or shift a predicted per-atom property based on (learnable) per-species/type parameters.
+
+ Args:
+ field: the per-atom field to scale/shift.
+ num_types: the number of types in the model.
+ shifts: the initial shifts to use, one per atom type.
+ scales: the initial scales to use, one per atom type.
+ arguments_in_dataset_units: if ``True``, says that the provided shifts/scales are in dataset
+ units (in which case they will be rescaled appropriately by any global rescaling later
+ applied to the model); if ``False``, the provided shifts/scales will be used without modification.
+
+ For example, if identity shifts/scales of zeros and ones are provided, this should be ``False``.
+ But if scales/shifts computed from the training data are used, and are thus in dataset units,
+ this should be ``True``.
+ out_field: the output field; defaults to ``field``.
+ """
+
+ field: str
+ out_field: str
+ scales_trainble: bool
+ shifts_trainable: bool
+ has_scales: bool
+ has_shifts: bool
+
+ def __init__(
+ self,
+ field: str,
+ num_types: int,
+ shifts: Optional[List[float]],
+ scales: Optional[List[float]],
+ out_field: Optional[str] = None,
+ scales_trainable: bool = False,
+ shifts_trainable: bool = False,
+ **kwargs,
+ ):
+ super().__init__()
+ self.num_types = num_types
+ self.field = field
+ self.out_field = f"shifted_{field}" if out_field is None else out_field
+
+ self.has_shifts = shifts is not None
+ if shifts is not None:
+ shifts = torch.as_tensor(shifts, dtype=torch.get_default_dtype())
+ if len(shifts.reshape([-1])) == 1:
+ shifts = torch.ones(num_types) * shifts
+ assert shifts.shape == (num_types,), f"Invalid shape of shifts {shifts}"
+ self.shifts_trainable = shifts_trainable
+ if shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+ self.has_scales = scales is not None
+ if scales is not None:
+ scales = torch.as_tensor(scales, dtype=torch.get_default_dtype())
+ if len(scales.reshape([-1])) == 1:
+ scales = torch.ones(num_types) * scales
+ assert scales.shape == (num_types,), f"Invalid shape of scales {scales}"
+ self.scales_trainable = scales_trainable
+ if scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+
+ if not (self.has_scales or self.has_shifts):
+ return data
+
+ species_idx = data[AtomicDataDict.ATOM_TYPE_KEY]
+ in_field = data[self.field]
+ assert len(in_field) == len(
+ species_idx
+ ), "in_field doesnt seem to have correct per-atom shape"
+ if self.has_scales:
+ in_field = self.scales[species_idx].view(-1, 1) * in_field
+ if self.has_shifts:
+ in_field = self.shifts[species_idx].view(-1, 1) + in_field
+ data[self.out_field] = in_field
+ return data
+
+ # def update_for_rescale(self, rescale_module):
+ # if hasattr(rescale_module, "related_scale_keys"):
+ # if self.out_field not in rescale_module.related_scale_keys:
+ # return
+ # if self.arguments_in_dataset_units and rescale_module.has_scale:
+ # logging.debug(
+ # f"PerSpeciesScaleShift's arguments were in dataset units; rescaling:\n "
+ # f"Original scales: {TypeMapper.format(self.scales, self.type_names) if self.has_scales else 'n/a'} "
+ # f"shifts: {TypeMapper.format(self.shifts, self.type_names) if self.has_shifts else 'n/a'}"
+ # )
+ # with torch.no_grad():
+ # if self.has_scales:
+ # self.scales.div_(rescale_module.scale_by)
+ # if self.has_shifts:
+ # self.shifts.div_(rescale_module.scale_by)
+ # logging.debug(
+ # f" New scales: {TypeMapper.format(self.scales, self.type_names) if self.has_scales else 'n/a'} "
+ # f"shifts: {TypeMapper.format(self.shifts, self.type_names) if self.has_shifts else 'n/a'}"
+ # )
+
+class PerEdgeSpeciesScaleShift(torch.nn.Module):
+ """Sum edgewise energies.
+
+ Includes optional per-species-pair edgewise energy scales.
+ """
+
+ field: str
+ out_field: str
+ scales_trainble: bool
+ shifts_trainable: bool
+ has_scales: bool
+ has_shifts: bool
+
+ def __init__(
+ self,
+ field: str,
+ num_types: int,
+ shifts: Optional[List[float]],
+ scales: Optional[List[float]],
+ out_field: Optional[str] = None,
+ scales_trainable: bool = False,
+ shifts_trainable: bool = False,
+ **kwargs,
+ ):
+ """Sum edges into nodes."""
+ super(PerEdgeSpeciesScaleShift, self).__init__()
+ self.num_types = num_types
+ self.field = field
+ self.out_field = f"shifted_{field}" if out_field is None else out_field
+
+ self.has_shifts = shifts is not None
+ self.has_scales = scales is not None
+ if scales is not None:
+ scales = torch.as_tensor(scales, dtype=torch.get_default_dtype())
+ if len(scales.reshape([-1])) == 1:
+ scales = torch.ones(num_types, num_types) * scales
+ assert scales.shape == (num_types, num_types,), f"Invalid shape of scales {scales}"
+ self.scales_trainable = scales_trainable
+ if scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ if shifts is not None:
+ shifts = torch.as_tensor(shifts, dtype=torch.get_default_dtype())
+ if len(shifts.reshape([-1])) == 1:
+ shifts = torch.ones(num_types, num_types) * shifts
+ assert shifts.shape == (num_types, num_types,), f"Invalid shape of shifts {shifts}"
+ self.shifts_trainable = shifts_trainable
+ if shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+
+ if not (self.has_scales or self.has_shifts):
+ return data
+
+ edge_center = data[AtomicDataDict.EDGE_INDEX_KEY][0]
+ edge_neighbor = data[AtomicDataDict.EDGE_INDEX_KEY][1]
+
+ species_idx = data[AtomicDataDict.ATOM_TYPE_KEY].flatten()
+ center_species = species_idx[edge_center]
+ neighbor_species = species_idx[edge_neighbor]
+ in_field = data[self.field]
+
+ assert len(in_field) == len(
+ edge_center
+ ), "in_field doesnt seem to have correct per-edge shape"
+
+
+ if self.has_scales:
+ in_field = self.scales[center_species, neighbor_species].view(-1, 1) * in_field
+ if self.has_shifts:
+ in_field = self.shifts[center_species, neighbor_species].view(-1, 1) + in_field
+
+ data[self.out_field] = in_field
+
+ return data
+
+class E3PerEdgeSpeciesScaleShift(torch.nn.Module):
+ """Sum edgewise energies.
+
+ Includes optional per-species-pair edgewise energy scales.
+ """
+
+ field: str
+ out_field: str
+ scales_trainble: bool
+ shifts_trainable: bool
+ has_scales: bool
+ has_shifts: bool
+
+ def __init__(
+ self,
+ field: str,
+ num_types: int,
+ irreps_in,
+ shifts: Optional[torch.Tensor],
+ scales: Optional[torch.Tensor],
+ out_field: Optional[str] = None,
+ scales_trainable: bool = False,
+ shifts_trainable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ """Sum edges into nodes."""
+ super(E3PerEdgeSpeciesScaleShift, self).__init__()
+ self.num_types = num_types
+ self.field = field
+ self.out_field = f"shifted_{field}" if out_field is None else out_field
+ self.irreps_in = irreps_in
+ self.num_scalar = 0
+ self.device = device
+ self.dtype = dtype
+ self.shift_index = []
+ self.scale_index = []
+
+ start = 0
+ start_scalar = 0
+ for mul, ir in irreps_in:
+ if str(ir) == "0e":
+ self.num_scalar += mul
+ self.shift_index += list(range(start_scalar, start_scalar + mul))
+ start_scalar += mul
+ else:
+ self.shift_index += [-1] * mul * ir.dim
+
+ for _ in range(mul):
+ self.scale_index += [start] * ir.dim
+ start += 1
+
+ self.shift_index = torch.as_tensor(self.shift_index, dtype=torch.long, device=device)
+ self.scale_index = torch.as_tensor(self.scale_index, dtype=torch.long, device=device)
+
+ self.has_shifts = shifts is not None
+ self.has_scales = scales is not None
+ if scales is not None:
+ scales = torch.as_tensor(scales, dtype=self.dtype, device=device)
+ if len(scales.reshape(-1)) == 1:
+ scales = scales * torch.ones(num_types*num_types, self.irreps_in.num_irreps, dtype=self.dtype, device=self.device)
+ assert scales.shape == (num_types*num_types, self.irreps_in.num_irreps), f"Invalid shape of scales {scales}"
+ self.scales_trainable = scales_trainable
+ if scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ if shifts is not None:
+ shifts = torch.as_tensor(shifts, dtype=self.dtype, device=device)
+ if len(shifts.reshape(-1)) == 1:
+ shifts = shifts * torch.ones(num_types*num_types, self.num_scalar, dtype=self.dtype, device=self.device)
+ assert shifts.shape == (num_types*num_types, self.num_scalar), f"Invalid shape of shifts {shifts}"
+ self.shifts_trainable = shifts_trainable
+ if shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+ def set_scale_shift(self, scales: torch.Tensor=None, shifts: torch.Tensor=None):
+ self.has_scales = scales is not None or self.has_scales
+ if scales is not None:
+ assert scales.shape == (self.num_types*self.num_types, self.irreps_in.num_irreps), f"Invalid shape of scales {scales}"
+ if self.scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ self.has_shifts = shifts is not None or self.has_shifts
+ if shifts is not None:
+ assert shifts.shape == (self.num_types*self.num_types, self.num_scalar), f"Invalid shape of shifts {shifts}"
+ if self.shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+
+ if not (self.has_scales or self.has_shifts):
+ return data
+
+ edge_center = data[AtomicDataDict.EDGE_INDEX_KEY][0]
+
+ species_idx = data[AtomicDataDict.EDGE_TYPE_KEY].flatten()
+ in_field = data[self.field]
+
+ assert len(in_field) == len(
+ edge_center
+ ), "in_field doesnt seem to have correct per-edge shape"
+
+ if self.has_scales:
+ in_field = self.scales[species_idx][:,self.scale_index].view(-1, self.irreps_in.dim) * in_field
+ if self.has_shifts:
+ shifts = self.shifts[species_idx][:,self.shift_index[self.shift_index>=0]].view(-1, self.num_scalar)
+ in_field[:, self.shift_index>=0] = shifts + in_field[:, self.shift_index>=0]
+
+ data[self.out_field] = in_field
+
+ return data
+
+class E3PerSpeciesScaleShift(torch.nn.Module):
+ """Scale and/or shift a predicted per-atom property based on (learnable) per-species/type parameters.
+
+ Args:
+ field: the per-atom field to scale/shift.
+ num_types: the number of types in the model.
+ shifts: the initial shifts to use, one per atom type.
+ scales: the initial scales to use, one per atom type.
+ arguments_in_dataset_units: if ``True``, says that the provided shifts/scales are in dataset
+ units (in which case they will be rescaled appropriately by any global rescaling later
+ applied to the model); if ``False``, the provided shifts/scales will be used without modification.
+
+ For example, if identity shifts/scales of zeros and ones are provided, this should be ``False``.
+ But if scales/shifts computed from the training data are used, and are thus in dataset units,
+ this should be ``True``.
+ out_field: the output field; defaults to ``field``.
+ """
+
+ field: str
+ out_field: str
+ scales_trainble: bool
+ shifts_trainable: bool
+ has_scales: bool
+ has_shifts: bool
+
+ def __init__(
+ self,
+ field: str,
+ num_types: int,
+ irreps_in,
+ shifts: Optional[torch.Tensor],
+ scales: Optional[torch.Tensor],
+ out_field: Optional[str] = None,
+ scales_trainable: bool = False,
+ shifts_trainable: bool = False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ super().__init__()
+ self.num_types = num_types
+ self.field = field
+ self.out_field = f"shifted_{field}" if out_field is None else out_field
+ self.irreps_in = irreps_in
+ self.num_scalar = 0
+ self.shift_index = []
+ self.scale_index = []
+ self.dtype = dtype
+ self.device = device
+
+ start = 0
+ start_scalar = 0
+ for mul, ir in irreps_in:
+ # only the scalar irreps can be shifted
+ # all the irreps can be scaled
+ if str(ir) == "0e":
+ self.num_scalar += mul
+ self.shift_index += list(range(start_scalar, start_scalar + mul))
+ start_scalar += mul
+ else:
+ self.shift_index += [-1] * mul * ir.dim
+ for _ in range(mul):
+ self.scale_index += [start] * ir.dim
+ start += 1
+
+ self.shift_index = torch.as_tensor(self.shift_index, dtype=torch.long, device=device)
+ self.scale_index = torch.as_tensor(self.scale_index, dtype=torch.long, device=device)
+
+ self.has_shifts = shifts is not None
+ if shifts is not None:
+ shifts = torch.as_tensor(shifts, dtype=self.dtype, device=device)
+ if len(shifts.reshape([-1])) == 1:
+ shifts = torch.ones(num_types, self.num_scalar, dtype=dtype, device=device) * shifts
+ assert shifts.shape == (num_types,self.num_scalar), f"Invalid shape of shifts {shifts}"
+ self.shifts_trainable = shifts_trainable
+ if shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+ self.has_scales = scales is not None
+ if scales is not None:
+ scales = torch.as_tensor(scales, dtype=torch.get_default_dtype())
+ if len(scales.reshape([-1])) == 1:
+ scales = torch.ones(num_types, self.irreps_in.num_irreps, dtype=dtype, device=device) * scales
+ assert scales.shape == (num_types,self.irreps_in.num_irreps), f"Invalid shape of scales {scales}"
+ self.scales_trainable = scales_trainable
+ if scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ def set_scale_shift(self, scales: torch.Tensor=None, shifts: torch.Tensor=None):
+ self.has_scales = scales is not None or self.has_scales
+ if scales is not None:
+ assert scales.shape == (self.num_types, self.irreps_in.num_irreps), f"Invalid shape of scales {scales}"
+ if self.scales_trainable:
+ self.scales = torch.nn.Parameter(scales)
+ else:
+ self.register_buffer("scales", scales)
+
+ self.has_shifts = shifts is not None or self.has_shifts
+ if shifts is not None:
+ assert shifts.shape == (self.num_types, self.num_scalar), f"Invalid shape of shifts {shifts}"
+ if self.shifts_trainable:
+ self.shifts = torch.nn.Parameter(shifts)
+ else:
+ self.register_buffer("shifts", shifts)
+
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+
+ if not (self.has_scales or self.has_shifts):
+ return data
+
+ species_idx = data[AtomicDataDict.ATOM_TYPE_KEY].flatten()
+ in_field = data[self.field]
+ assert len(in_field) == len(
+ species_idx
+ ), "in_field doesnt seem to have correct per-atom shape"
+ if self.has_scales:
+ in_field = self.scales[species_idx][:,self.scale_index].view(-1, self.irreps_in.dim) * in_field
+ if self.has_shifts:
+ shifts = self.shifts[species_idx][:,self.shift_index[self.shift_index>=0]].view(-1, self.num_scalar)
+ in_field[:, self.shift_index>=0] = shifts + in_field[:, self.shift_index>=0]
+ data[self.out_field] = in_field
+ return data
+
+
+@compile_mode("script")
+class E3ElementLinear(torch.nn.Module):
+ """Sum edgewise energies.
+ Includes optional per-species-pair edgewise energy scales.
+ """
+
+ weight_numel: int
+
+ def __init__(
+ self,
+ irreps_in: o3.Irreps,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ super(E3ElementLinear, self).__init__()
+ self.irreps_in = irreps_in
+ self.num_scalar = 0
+ self.device = device
+ self.dtype = dtype
+ self.shift_index = []
+ self.scale_index = []
+
+ count_scales= 0
+ count_shift = 0
+ for mul, ir in irreps_in:
+ if str(ir) == "0e":
+ self.num_scalar += mul
+ self.shift_index += list(range(count_shift, count_shift + mul))
+ count_shift += mul
+ else:
+ self.shift_index += [-1] * mul * ir.dim
+
+ for _ in range(mul):
+ self.scale_index += [count_scales] * ir.dim
+ count_scales += 1
+
+ self.shift_index = torch.as_tensor(self.shift_index, dtype=torch.int64, device=self.device)
+ self.scale_index = torch.as_tensor(self.scale_index, dtype=torch.int64, device=self.device)
+
+ self.weight_numel = irreps_in.num_irreps + self.num_scalar
+ assert count_scales + count_shift == self.weight_numel
+ self.num_scales = count_scales
+ self.num_shifts = count_shift
+
+ def forward(self, x: torch.Tensor, weights: Optional[torch.Tensor]=None):
+
+ scales = weights[:, :self.num_scales] if weights is not None else None
+ if weights is not None:
+ if weights.shape[1] > self.num_scales:
+ shifts = weights[:, self.num_scales:]
+ else:
+ shifts = None
+ else:
+ shifts = None
+
+ if scales is not None:
+ assert len(scales) == len(
+ x
+ ), "in_field doesnt seem to have correct shape as scales"
+ x = scales[:,self.scale_index].reshape(x.shape[0], -1) * x
+ else:
+ x = x
+
+ if shifts is not None:
+ assert len(shifts) == len(
+ x
+ ), "in_field doesnt seem to have correct shape as shifts"
+
+ # bias = torch.zeros_like(x)
+ # bias[:, self.shift_index.ge(0)] = shifts[:,self.shift_index[self.shift_index.ge(0)]].reshape(-1, self.num_scalar)
+ # x = x + bias
+ x[:, self.shift_index.ge(0)] = shifts[:,self.shift_index[self.shift_index.ge(0)]].reshape(-1, self.num_scalar) + x[:, self.shift_index.ge(0)]
+ else:
+ x = x
+
+ return x
\ No newline at end of file
diff --git a/dptb/nn/sktb/__init__.py b/dptb/nn/sktb/__init__.py
new file mode 100644
index 00000000..d7a1eeef
--- /dev/null
+++ b/dptb/nn/sktb/__init__.py
@@ -0,0 +1,11 @@
+from .hopping import HoppingFormula
+from .onsite import OnsiteFormula
+from .bondlengthDB import bond_length_list
+
+
+
+__all__ = [
+ 'HoppingFormula',
+ 'OnsiteFormula',
+ 'bond_length_list',
+]
\ No newline at end of file
diff --git a/dptb/nn/sktb/bondlengthDB.py b/dptb/nn/sktb/bondlengthDB.py
new file mode 100644
index 00000000..029b879e
--- /dev/null
+++ b/dptb/nn/sktb/bondlengthDB.py
@@ -0,0 +1,36 @@
+# Onsite energies database, loaded from GAPW lda potentials. stored as
+# A dictionary of dictionaries. The first dictionary is the element name, and the
+# second dictionary is the orbital name. The orbital name is the key, and the value is the onsite energy.
+import torch
+
+#
+# Contains the elements as follows:
+
+# AtomSymbol=[
+# 'H', 'He',
+# 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne',
+# 'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar',
+# 'K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr',
+# 'Rb', 'Sr', 'Y', 'Zr', 'Nb', 'Mo', , 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'I', 'Xe',
+# 'Cs', 'Ba', 'Hf', 'Ta', 'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Rn'
+# ]
+
+element = ["H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
+ "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr",
+ "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Lu", "Hf", "Ta",
+ "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "Ra", "Th"]
+
+bond_length_list = torch.tensor([1.6,1.4,5.0,3.4,3.0,3.2,3.4,3.1,2.7,3.2,5.9,5.0,5.9,4.4,4.0,3.9,
+ 3.8,4.5,6.5,4.9,5.1,4.2,4.3,4.7,3.6,3.7,3.3,3.7,5.2,4.6,5.9,4.5,4.4,
+ 4.5,4.3,4.8,9.1,6.9,5.7,5.2,5.2,4.3,4.1,4.1,4.0,4.4,6.5,5.4,4.8,4.7,
+ 5.2,5.2,6.2,5.2,10.6,7.7,7.4,5.9,5.2,4.8,4.2,4.2,4.0,3.9,3.8,4.8,6.7,
+ 7.3,5.7,5.8])
+
+bond_length = {
+ 'H': 1.6, 'He': 1.4, 'Li': 5.0, 'Be': 3.4, 'B': 3.0, 'C': 3.2, 'N': 3.4, 'O': 3.1, 'F': 2.7, 'Ne': 3.2, 'Na': 5.9, 'Mg': 5.0,
+ 'Al': 5.9, 'Si': 4.4, 'P': 4.0, 'S': 3.9, 'Cl': 3.8, 'Ar': 4.5, 'K': 6.5, 'Ca': 4.9, 'Sc': 5.1, 'Ti': 4.2, 'V': 4.3, 'Cr': 4.7,
+ 'Mn': 3.6, 'Fe': 3.7, 'Co': 3.3, 'Ni': 3.7, 'Cu': 5.2, 'Zn': 4.6, 'Ga': 5.9, 'Ge': 4.5, 'As': 4.4, 'Se': 4.5, 'Br': 4.3, 'Kr': 4.8,
+ 'Rb': 9.1, 'Sr': 6.9, 'Y': 5.7, 'Zr': 5.2, 'Nb': 5.2, 'Mo': 4.3, 'Tc': 4.1, 'Ru': 4.1, 'Rh': 4.0, 'Pd': 4.4, 'Ag': 6.5, 'Cd': 5.4,
+ 'In': 4.8, 'Sn': 4.7, 'Sb': 5.2, 'Te': 5.2, 'I': 6.2, 'Xe': 5.2, 'Cs': 10.6, 'Ba': 7.7, 'La': 7.4, 'Lu': 5.9, 'Hf': 5.2, 'Ta': 4.8,
+ 'W': 4.2, 'Re': 4.2, 'Os': 4.0, 'Ir': 3.9, 'Pt': 3.8, 'Au': 4.8, 'Hg': 6.7, 'Tl': 7.3, 'Pb': 5.7, 'Bi': 5.8, 'Po': 5.5, 'Ra': 7.0,
+ 'Th': 6.2}
diff --git a/dptb/nn/sktb/hopping.py b/dptb/nn/sktb/hopping.py
new file mode 100644
index 00000000..9d4fe0e4
--- /dev/null
+++ b/dptb/nn/sktb/hopping.py
@@ -0,0 +1,222 @@
+# define the integrals formula.
+import torch
+from abc import ABC, abstractmethod
+from dptb.nn.sktb.bondlengthDB import bond_length_list
+
+class BaseHopping(ABC):
+ def __init__(self) -> None:
+ pass
+
+ @abstractmethod
+ def get_skhij(self, rij, **kwargs):
+ '''This is a wrap function for a self-defined formula of sk integrals. one can easily modify it into whatever form they want.
+
+ Returns
+ -------
+ The function defined by type is called to cal skhij and returned.
+
+ '''
+ pass
+
+class HoppingFormula(BaseHopping):
+ num_paras_dict = {
+ 'varTang96': 4,
+ 'powerlaw': 2,
+ 'NRL0': 4,
+ "NRL1": 4,
+ 'custom': None,
+ }
+
+ def __init__(self, functype='varTang96',overlap=False) -> None:
+ super(HoppingFormula, self).__init__()
+ # one can modify this by add his own formula with the name functype to deifine num of pars.
+ self.overlap = overlap
+ if functype == 'varTang96':
+ assert hasattr(self, 'varTang96')
+
+ elif functype == 'powerlaw':
+ assert hasattr(self, 'powerlaw')
+
+ elif functype in ['NRL0', "NRL1"]:
+ assert hasattr(self, 'NRL_HOP')
+ if overlap:
+ assert hasattr(self, 'NRL_OVERLAP')
+
+ elif functype =='custom':
+ # the functype custom, is for user to define their own formula.
+ # just modify custom to the name of your formula.
+ # and define the funnction self.custom(rij, paraArray, **kwargs)
+ assert hasattr(self, 'custom')
+ else:
+ raise ValueError('No such formula')
+
+ self.functype = functype
+ self.num_paras = self.num_paras_dict[functype]
+
+
+ def get_skhij(self, rij, **kwargs):
+ '''This is a wrap function for a self-defined formula of sk integrals. one can easily modify it into whatever form they want.
+
+ Returns
+ -------
+ The function defined by functype is called to cal skhij and returned.
+
+ '''
+
+ if self.functype == 'varTang96':
+ return self.varTang96(rij=rij, **kwargs)
+ elif self.functype == 'powerlaw':
+ return self.powerlaw(rij=rij, **kwargs)
+ elif self.functype.startswith('NRL'):
+ return self.NRL_HOP(rij=rij, **kwargs)
+ else:
+ raise ValueError('No such formula')
+
+ def get_sksij(self,rij,**kwargs):
+ '''This is a wrap function for a self-defined formula of sk overlap. one can easily modify it into whatever form they want.
+
+ Returns
+ -------
+ The function defined by functype is called to cal sk sij and returned.
+
+ '''
+ assert self.overlap, 'overlap is False, no overlap function is defined.'
+
+ if self.functype == 'NRL0':
+ return self.NRL_OVERLAP0(rij=rij, **kwargs)
+ if self.functype == 'NRL1':
+ return self.NRL_OVERLAP1(rij=rij, **kwargs)
+ elif self.functype == "powerlaw":
+ return self.powerlaw(rij=rij, **kwargs)
+ elif self.functype == "varTang96":
+ return self.varTang96(rij=rij, **kwargs)
+ else:
+ raise ValueError('No such formula')
+
+
+ def varTang96(self, rij: torch.Tensor, paraArray: torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs):
+ """> This function calculates the value of the variational form of Tang et al 1996. without the
+ environment dependent
+
+ $$ h(rij) = \alpha_1 * (rij)^(-\alpha_2) * exp(-\alpha_3 * (rij)^(\alpha_4))$$
+
+ Parameters
+ ----------
+ rij : torch.Tensor([N, 1]/[N])
+ the bond length vector, have the same length of the bond index vector.
+ paraArray : torch.Tensor([N, ..., 4])
+ The parameters for computing varTang96's type hopping integrals, the first dimension should have the
+ same length of the bond index vector, while the last dimenion if 4, which is the number of parameters
+ for each varTang96's type formula.
+ rcut : torch.Tensor, optional
+ cut-off by half at which value, by default torch.tensor(6)
+ w : torch.Tensor, optional
+ the decay factor, the larger the smoother, by default 0.1
+
+ Returns
+ -------
+ _type_
+ _description_
+ """
+
+ rij = rij.reshape(-1)
+ assert paraArray.shape[-1] == 4 and paraArray.shape[0] == len(rij), 'paraArray should be a 2d tensor with the last dimenion if 4, which is the number of parameters for each varTang96\'s type formula.'
+ alpha1, alpha2, alpha3, alpha4 = paraArray[..., 0], paraArray[..., 1].abs(), paraArray[..., 2].abs(), paraArray[..., 3].abs()
+ shape = [-1]+[1] * (len(alpha1.shape)-1)
+ rij = rij.reshape(shape)
+ return alpha1 * rij**(-alpha2) * torch.exp(-alpha3 * rij**alpha4)/(1+torch.exp((rij-rs)/w))
+
+ def powerlaw(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs):
+ """> This function calculates the value of the variational form of Tang et al 1996. without the
+ environment dependent
+
+ $$ h(rij) = \alpha_1 * (rij / r_ij0)^(\lambda + \alpha_2)
+ """
+
+ #alpha1, alpha2, alpha3, alpha4 = paraArray[:, 0], paraArray[:, 1]**2, paraArray[:, 2]**2, paraArray[:, 3]**2
+ alpha1, alpha2 = paraArray[..., 0], paraArray[..., 1].abs()
+ #[N, n_op]
+ shape = [-1]+[1] * (len(alpha1.shape)-1)
+ # [-1, 1]
+ rij = rij.reshape(shape)
+ r0 = r0.reshape(shape)
+
+ r0 = r0 / 1.8897259886
+
+ return alpha1 * (r0/rij)**(1 + alpha2) / (1+torch.exp((rij-rs)/w))
+
+ def NRL_HOP(self, rij, paraArray, rc:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs):
+ """
+ This function calculates the SK integral value of the form of NRL-TB
+
+ H_{ll'u} = (a + b R + c R^2)exp(-d^2 R) f(R)
+ a,b,c,d are the parameters, R is r_ij
+
+ f(r_ij) = [1+exp((r_ij-rcut+5w)/w)]^-1; (r_ij < rcut)
+ = 0; (r_ij >= rcut)
+
+ """
+ rij = rij.reshape(-1)
+ a, b, c, d = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3]
+ shape = [-1]+[1] * (len(a.shape)-1)
+ rij = rij.reshape(shape)
+ f_rij = 1/(1+torch.exp((rij-rc+5*w)/w))
+ f_rij[rij>=rc] = 0.0
+
+ return (a + b * rij + c * rij**2) * torch.exp(-d**2 * rij)*f_rij
+
+ def NRL_OVERLAP0(self, rij, paraArray, paraconst, rc:torch.float32 = torch.tensor(6), w:torch.float32 = 0.1, **kwargs):
+ """
+ This function calculates the Overlap value of the form of NRL-TB
+
+ S_{ll'u} = (delta_ll' + a R + b R^2 + c R^3)exp(-d^2 R) f(R)
+ a,b,c,d are the parameters, R is r_ij
+
+ f(r_ij) = [1+exp((r_ij-rcut+5w)/w)]^-1; (r_ij < rcut)
+ = 0; (r_ij >= rcut)
+ # delta
+ """
+
+ assert paraArray.shape[:-1] == paraconst.shape, 'paraArray and paraconst should have the same shape except the last dimenion.'
+ rij = rij.reshape(-1)
+ assert len(rij) == len(paraArray), 'rij and paraArray should have the same length.'
+
+ a, b, c, d = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3]
+ shape = [-1]+[1] * (len(a.shape)-1)
+ rij = rij.reshape(shape)
+
+ f_rij = 1/(1+torch.exp((rij-rc+5*w)/w))
+ f_rij[rij>=rc] = 0.0
+
+ return (a + b * rij + c * rij**2) * torch.exp(-d**2 * rij)*f_rij
+
+ def NRL_OVERLAP1(self, rij, paraArray, paraconst, rc:torch.float32 = torch.tensor(6), w:torch.float32 = 0.1, **kwargs):
+ """
+ This function calculates the Overlap value of the form of NRL-TB
+
+ S_{ll'u} = (delta_ll' + a R + b R^2 + c R^3)exp(-d^2 R) f(R)
+ a,b,c,d are the parameters, R is r_ij
+
+ f(r_ij) = [1+exp((r_ij-rcut+5w)/w)]^-1; (r_ij < rcut)
+ = 0; (r_ij >= rcut)
+ # delta
+ """
+
+ assert paraArray.shape[:-1] == paraconst.shape, 'paraArray and paraconst should have the same shape except the last dimenion.'
+ rij = rij.reshape(-1)
+ assert len(rij) == len(paraArray), 'rij and paraArray should have the same length.'
+
+ a, b, c, d = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3]
+ delta_ll = paraconst
+ shape = [-1]+[1] * (len(a.shape)-1)
+ rij = rij.reshape(shape)
+
+ f_rij = 1/(1+torch.exp((rij-rc+5*w)/w))
+ f_rij[rij>=rc] = 0.0
+
+ return (delta_ll + a * rij + b * rij**2 + c * rij**3) * torch.exp(-d**2 * rij)*f_rij
+
+ @classmethod
+ def num_params(cls, funtype):
+ return cls.num_paras_dict[funtype]
+
\ No newline at end of file
diff --git a/dptb/nn/sktb/onsite.py b/dptb/nn/sktb/onsite.py
new file mode 100644
index 00000000..032a4be1
--- /dev/null
+++ b/dptb/nn/sktb/onsite.py
@@ -0,0 +1,154 @@
+# define the integrals formula.
+import torch as th
+import torch
+from typing import List, Union
+from abc import ABC, abstractmethod
+from torch_runstats.scatter import scatter
+from dptb.nn.sktb.onsiteDB import onsite_energy_database
+from dptb.data.transforms import OrbitalMapper
+
+
+class BaseOnsite(ABC):
+ def __init__(self) -> None:
+ pass
+
+ @abstractmethod
+ def get_skEs(self, **kwargs):
+ '''This is a wrap function for a self-defined formula of onsite energies. one can easily modify it into whatever form they want.
+
+ Returns
+ -------
+ The function defined by type is called to cal onsite energies and returned.
+
+ '''
+ pass
+
+
+class OnsiteFormula(BaseOnsite):
+ num_paras_dict = {
+ 'uniform': 1,
+ 'none': 0,
+ 'strain': 0,
+ "NRL": 4,
+ "custom": None,
+ }
+
+ def __init__(
+ self,
+ idp: Union[OrbitalMapper, None]=None,
+ functype='none',
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu")) -> None:
+ super().__init__()
+ if functype in ['none', 'strain']:
+ pass
+ elif functype == 'uniform':
+ assert hasattr(self, 'uniform')
+
+ elif functype == 'NRL':
+ assert hasattr(self, 'NRL')
+
+ elif functype == 'custom':
+ assert hasattr(self, 'custom')
+ else:
+ raise ValueError('No such formula')
+
+ self.functype = functype
+ self.num_paras = self.num_paras_dict[functype]
+
+ self.idp = idp
+ if self.functype in ["uniform", "none", "strain"]:
+ self.E_base = torch.zeros(self.idp.num_types, self.idp.n_onsite_Es, dtype=dtype, device=device)
+ for asym, idx in self.idp.chemical_symbol_to_type.items():
+ self.E_base[idx] = torch.zeros(self.idp.n_onsite_Es)
+ for ot in self.idp.basis[asym]:
+ fot = self.idp.basis_to_full_basis[asym][ot]
+ self.E_base[idx][self.idp.skonsite_maps[fot]] = onsite_energy_database[asym][ot]
+
+ def get_skEs(self, **kwargs):
+ if self.functype == 'uniform':
+ return self.uniform(**kwargs)
+ if self.functype == 'NRL':
+ return self.NRL(**kwargs)
+ if self.functype in ['none', 'strain']:
+ return self.none(**kwargs)
+
+ def none(self, atomic_numbers: torch.Tensor, **kwargs):
+ """The none onsite function, the energy output is directly loaded from the onsite Database.
+ Parameters
+ ----------
+ atomic_numbers : torch.Tensor(N)
+ The atomic number list.
+
+ Returns
+ -------
+ torch.Tensor(N, n_orb)
+ the onsite energies by composing results from nn and ones from database.
+ """
+ atomic_numbers = atomic_numbers.reshape(-1)
+
+ idx = self.idp.transform_atom(atomic_numbers)
+
+ return self.E_base[idx]
+
+ def uniform(self, atomic_numbers: torch.Tensor, nn_onsite_paras: torch.Tensor, **kwargs):
+ """The uniform onsite function, that have the same onsite energies for one specific orbital of a atom type.
+
+ Parameters
+ ----------
+ atomic_numbers : torch.Tensor(N) or torch.Tensor(N,1)
+ The atomic number list.
+ nn_onsite_paras : torch.Tensor(N_atom_type, n_orb)
+ The nn fitted parameters for onsite energies.
+
+ Returns
+ -------
+ torch.Tensor(N, n_orb)
+ the onsite energies by composing results from nn and ones from database.
+ """
+ atomic_numbers = atomic_numbers.reshape(-1)
+ if nn_onsite_paras.shape[-1] == 1:
+ nn_onsite_paras = nn_onsite_paras.squeeze(-1)
+
+ assert len(nn_onsite_paras) == self.E_base.shape[0]
+
+ idx = self.idp.transform_atom(atomic_numbers)
+
+ return nn_onsite_paras[idx] + self.none(atomic_numbers=atomic_numbers)
+
+
+ def NRL(self, atomic_numbers, onsitenv_index, onsitenv_length, nn_onsite_paras, rc:th.float32 = th.tensor(6), w:th.float32 = 0.1, lda=1.0, **kwargs):
+ """ This is NRL-TB formula for onsite energies.
+
+ rho_i = \sum_j exp(- lda**2 r_ij) f(r_ij)
+
+ E_il = a_l + b_l rho_i^(2/3) + c_l rho_i^(4/3) + d_l rho_i^2
+
+ f(r_ij) = [1+exp((r_ij-rcut+5w)/w)]^-1; (r_ij < rcut)
+ = 0; (r_ij >= rcut)
+ Parameters
+ ----------
+ onsitenv_index: torch.LongTensor
+ env index shaped as [2, N]
+ onsitenv_length: torch.Tensor
+ env index shaped as [N] or [N,1]
+ nn_onsite_paras: torch.Tensor
+ [N, n_orb, 4]
+ rcut: float
+ the cutoff radius for onsite energies.
+ w: float
+ the decay for the cutoff smoth function.
+ lda: float
+ the decay for the calculateing rho.
+ """
+ atomic_numbers = atomic_numbers.reshape(-1)
+ idx = self.idp.transform_atom(atomic_numbers)
+ nn_onsite_paras = nn_onsite_paras[idx]
+ r_ijs = onsitenv_length.view(-1) # [N]
+ exp_rij = th.exp(-lda**2 * r_ijs)
+ f_rij = 1/(1+th.exp((r_ijs-rc+5*w)/w))
+ f_rij[r_ijs>=rc] = 0.0
+ rho_i = scatter(src=exp_rij * f_rij, index=onsitenv_index[0], dim=0, reduce="sum").unsqueeze(1) # [N_atom, 1]
+ a_l, b_l, c_l, d_l = nn_onsite_paras[:,:,0], nn_onsite_paras[:,:,1], nn_onsite_paras[:,:,2], nn_onsite_paras[:,:,3]
+ E_il = a_l + b_l * rho_i**(2/3) + c_l * rho_i**(4/3) + d_l * rho_i**2 # [N_atom, n_orb]
+ return E_il # [N_atom, n_orb]
\ No newline at end of file
diff --git a/dptb/nnsktb/onsiteDB_eV.py b/dptb/nn/sktb/onsiteDB.py
similarity index 100%
rename from dptb/nnsktb/onsiteDB_eV.py
rename to dptb/nn/sktb/onsiteDB.py
diff --git a/dptb/nn/type_encode/__init__.py b/dptb/nn/type_encode/__init__.py
new file mode 100644
index 00000000..d3d7c199
--- /dev/null
+++ b/dptb/nn/type_encode/__init__.py
@@ -0,0 +1,5 @@
+from .one_hot import OneHotAtomEncoding
+
+__all__ = [
+ OneHotAtomEncoding,
+]
diff --git a/dptb/nn/type_encode/one_hot.py b/dptb/nn/type_encode/one_hot.py
new file mode 100644
index 00000000..c0bd5eda
--- /dev/null
+++ b/dptb/nn/type_encode/one_hot.py
@@ -0,0 +1,32 @@
+import torch
+import torch.nn.functional
+from dptb.data import AtomicDataDict
+
+class OneHotAtomEncoding(torch.nn.Module):
+ """Copmute a one-hot floating point encoding of atoms' discrete atom types.
+
+ Args:
+ set_features: If ``True`` (default), ``node_features`` will be set in addition to ``node_attrs``.
+ """
+
+ num_types: int
+ set_features: bool
+
+ def __init__(
+ self,
+ num_types: int,
+ set_features: bool = True
+ ):
+ super().__init__()
+ self.num_types = num_types
+ self.set_features = set_features
+
+ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type:
+ type_numbers = data[AtomicDataDict.ATOM_TYPE_KEY].squeeze(-1)
+ one_hot = torch.nn.functional.one_hot(
+ type_numbers, num_classes=self.num_types
+ ).to(device=type_numbers.device, dtype=data[AtomicDataDict.POSITIONS_KEY].dtype)
+ data[AtomicDataDict.NODE_ATTRS_KEY] = one_hot
+ if self.set_features:
+ data[AtomicDataDict.NODE_FEATURES_KEY] = one_hot
+ return data
diff --git a/dptb/nn/type_encode/type_embedding.py b/dptb/nn/type_encode/type_embedding.py
new file mode 100644
index 00000000..2c0ad1f8
--- /dev/null
+++ b/dptb/nn/type_encode/type_embedding.py
@@ -0,0 +1,3 @@
+"""write the node and edge embedding for descriptors
+"""
+
diff --git a/dptb/nnops/base_tester.py b/dptb/nnops/base_tester.py
index 5799e491..e09efb77 100644
--- a/dptb/nnops/base_tester.py
+++ b/dptb/nnops/base_tester.py
@@ -5,6 +5,7 @@
from abc import ABCMeta, abstractmethod
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
from future.utils import with_metaclass
+from typing import Union
from dptb.utils.constants import dtype_dict
from dptb.plugins.base_plugin import PluginUser
@@ -65,6 +66,56 @@ def calc(self, **data):
def test(self) -> None:
pass
+class BaseTester(with_metaclass(ABCMeta, PluginUser)):
+
+ def __init__(
+ self,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ) -> None:
+ super(BaseTester, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+ self.dtype = dtype
+ self.device = device
+
+ ''' Here is for plugins.
+ plugins:
+ - iteration: events after every batch training iteration.
+ - update: the updates of model paras including networks and optimiser, such as leaning rate, etc. after the batch training.
+ - batch: events before batch training.
+ - epoch: events after epoch batch training
+ The difference b/w iteration and update the parameters, iteration takes in the batch output, loss etc., while update takes in model itself.
+ '''
+ self.iter = 1
+ self.ep = 1
+
+ def run(self):
+ for q in self.plugin_queues.values():
+ '''对四个事件调用序列进行最小堆排序。'''
+ heapq.heapify(q)
+
+ self.epoch()
+ # run plugins of epoch events.
+ self.call_plugins(queue_name='epoch', time=i)
+ self.lr_scheduler.step() # modify the lr at each epoch (should we add it to pluggins so we could record the lr scheduler process?)
+ self.ep += 1
+
+
+ @abstractmethod
+ def iteration(self, **data):
+ '''
+ conduct one step forward computation, used in train, test and validation.
+ '''
+ pass
+
+ @abstractmethod
+ def epoch(self) -> None:
+ """define a training iteration process
+ """
+ pass
+
if __name__ == '__main__':
a = [1, 2, 3]
diff --git a/dptb/nnops/base_trainer.py b/dptb/nnops/base_trainer.py
index 1bf9e363..70b0ee46 100644
--- a/dptb/nnops/base_trainer.py
+++ b/dptb/nnops/base_trainer.py
@@ -3,7 +3,7 @@
import logging
from dptb.utils.tools import get_lr_scheduler, j_must_have, get_optimizer
from abc import ABCMeta, abstractmethod
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
from future.utils import with_metaclass
from dptb.utils.constants import dtype_dict
from dptb.plugins.base_plugin import PluginUser
@@ -11,13 +11,20 @@
log = logging.getLogger(__name__)
+class BaseTrainer(with_metaclass(ABCMeta, PluginUser)):
-class Trainer(with_metaclass(ABCMeta, PluginUser)):
+ def __init__(
+ self,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ ) -> None:
+ super(BaseTrainer, self).__init__()
+
+ if isinstance(dtype, str):
+ dtype = dtype_dict[dtype]
+ self.dtype = dtype
+ self.device = device
- def __init__(self, jdata) -> None:
- super(Trainer, self).__init__()
- self.dtype = jdata["common_options"]["dtype"]
- self.device = jdata["common_options"]["device"]
''' Here is for plugins.
plugins:
- iteration: events after every batch training iteration.
@@ -26,21 +33,13 @@ def __init__(self, jdata) -> None:
- epoch: events after epoch batch training
The difference b/w iteration and update the parameters, iteration takes in the batch output, loss etc., while update takes in model itself.
'''
- self.iteration = 1
- self.epoch = 1
-
-
+ self.iter = 1
+ self.ep = 1
@abstractmethod
- def _init_param(self, jdata):
-
- pass
-
- @abstractmethod
- def build(self):
- '''
- init the model
- '''
+ def restart(self, checkpoint):
+ """init trainer from disk
+ """
pass
def run(self, epochs=1):
@@ -48,24 +47,30 @@ def run(self, epochs=1):
'''对四个事件调用序列进行最小堆排序。'''
heapq.heapify(q)
- for i in range(self.epoch, epochs + 1):
- self.train()
+ for i in range(self.ep, epochs + 1):
+ self.epoch()
# run plugins of epoch events.
self.call_plugins(queue_name='epoch', time=i)
- self.lr_scheduler.step() # modify the lr at each epoch (should we add it to pluggins so we could record the lr scheduler process?)
+
+ if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):
+ self.lr_scheduler.step(self.stats["train_loss"]["epoch_mean"])
+ else:
+ self.lr_scheduler.step() # modify the lr at each epoch (should we add it to pluggins so we could record the lr scheduler process?)
self.update()
- self.epoch += 1
+ self.ep += 1
@abstractmethod
- def calc(self, **data):
+ def iteration(self, **data):
'''
conduct one step forward computation, used in train, test and validation.
'''
pass
@abstractmethod
- def train(self) -> None:
+ def epoch(self) -> None:
+ """define a training iteration process
+ """
pass
@abstractmethod
diff --git a/dptb/nnops/loss.py b/dptb/nnops/loss.py
index 0f6cdbe1..bb894cc5 100644
--- a/dptb/nnops/loss.py
+++ b/dptb/nnops/loss.py
@@ -1,176 +1,403 @@
-import numpy as np
-import torch as th
-#import torchsort
-
-def loss_type1(criterion, eig_pred, eig_label,num_el,num_kp, band_min=0, band_max=None, spin_deg=2):
- norbs = eig_pred.shape[-1]
- nbanddft = eig_label.shape[-1]
- up_nband = min(norbs,nbanddft)
- num_val_band = int(num_el//spin_deg)
- num_k_val_band = int(num_kp * num_el // spin_deg)
- assert num_val_band <= up_nband
- if band_max is None:
- band_max = up_nband
- else:
- assert band_max <= up_nband
-
- band_min = int(band_min)
- band_max = int(band_max)
+import torch.nn as nn
+import torch
+from torch.nn.functional import mse_loss
+from dptb.utils.register import Register
+from dptb.nn.energy import Eigenvalues
+from dptb.nn.hamiltonian import E3Hamiltonian
+from typing import Any, Union, Dict
+from dptb.data import AtomicDataDict, AtomicData
+from dptb.data.transforms import OrbitalMapper
+from dptb.utils.torch_geometric import Batch
- assert band_min < band_max
- # shape of eigs [batch_size, num_kp, num_bands]
- assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
+"""this is the register class for descriptors
- # 对齐eig_pred和eig_label
- eig_pred_cut = eig_pred[:,:,band_min:band_max]
- eig_label_cut = eig_label[:,:,band_min:band_max]
-
- batch_size, num_kp, num_bands = eig_pred_cut.shape
-
- eig_pred_cut -= eig_pred_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
- eig_label_cut -= eig_label_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
-
- loss = criterion(eig_pred_cut,eig_label_cut)
-
- return loss
-
-def loss_soft_sort(criterion, eig_pred, eig_label,num_el,num_kp, sort_strength=0.5, kmax=None, kmin=0, band_min=0, band_max=None, spin_deg=2, gap_penalty=False, fermi_band=0, eta=1e-2, **kwarg):
- norbs = eig_pred.shape[-1]
- nbanddft = eig_label.shape[-1]
- up_nband = min(norbs,nbanddft)
- num_val_band = int(num_el//spin_deg)
- num_k_val_band = int(num_kp * num_el // spin_deg)
- assert num_val_band <= up_nband
- if band_max is None:
- band_max = up_nband
- else:
- assert band_max <= up_nband
+all descriptors inplemendeted should be a instance of nn.Module class, and provide a forward function that
+takes AtomicData class as input, and give AtomicData class as output.
+
+"""
+class Loss:
+ _register = Register()
+
+ def register(target):
+ return Loss._register.register(target)
- if kmax is None:
- kmax = num_kp
- else:
- assert kmax <= num_kp
+ def __new__(cls, method: str, **kwargs):
+ if method in Loss._register.keys():
+ return Loss._register[method](**kwargs)
+ else:
+ raise Exception(f"Loss method: {method} is not registered!")
+
+@Loss.register("eigvals")
+class EigLoss(nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ overlap: bool=False,
+ diff_on: bool=False,
+ eout_weight: float=0.01,
+ diff_weight: float=0.01,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ super(EigLoss, self).__init__()
+ self.loss = nn.MSELoss()
+ self.device = device
+ self.diff_on = diff_on
+ self.eout_weight = eout_weight
+ self.diff_weight = diff_weight
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb", device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ if not overlap:
+ self.eigenvalue = Eigenvalues(
+ idp=self.idp,
+ h_edge_field = AtomicDataDict.EDGE_FEATURES_KEY,
+ h_node_field = AtomicDataDict.NODE_FEATURES_KEY,
+ h_out_field = AtomicDataDict.HAMILTONIAN_KEY,
+ out_field = AtomicDataDict.ENERGY_EIGENVALUE_KEY,
+ s_edge_field = None,
+ s_node_field = None,
+ s_out_field = None,
+ dtype=dtype,
+ device=device,
+ )
+ else:
+ self.eigenvalue = Eigenvalues(
+ idp=self.idp,
+ h_edge_field = AtomicDataDict.EDGE_FEATURES_KEY,
+ h_node_field = AtomicDataDict.NODE_FEATURES_KEY,
+ h_out_field = AtomicDataDict.HAMILTONIAN_KEY,
+ out_field = AtomicDataDict.ENERGY_EIGENVALUE_KEY,
+ s_edge_field = AtomicDataDict.EDGE_OVERLAP_KEY,
+ s_node_field = AtomicDataDict.NODE_OVERLAP_KEY,
+ s_out_field = AtomicDataDict.OVERLAP_KEY,
+ dtype=dtype,
+ device=device,
+ )
+
+ self.overlap = overlap
- band_min = int(band_min)
- band_max = int(band_max)
+ def forward(
+ self,
+ data: AtomicDataDict,
+ ref_data: AtomicDataDict,
+ ):
+
+ total_loss = 0.
- assert band_min < band_max
- # shape of eigs [batch_size, num_kp, num_bands]
- assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
+ data = Batch.from_dict(data)
+ ref_data = Batch.from_dict(ref_data)
- eig_pred_cut = eig_pred[:,kmin:kmax,band_min:band_max]
- eig_label_cut = eig_label[:,kmin:kmax,band_min:band_max]
- batch_size, num_kp, num_bands = eig_pred_cut.shape
+ datalist = data.to_data_list()
+ ref_datalist = ref_data.to_data_list()
- eig_pred_cut -= eig_pred_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
- eig_label_cut -= eig_label_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
+ for data, ref_data in zip(datalist, ref_datalist):
+ data = self.eigenvalue(AtomicData.to_AtomicDataDict(data))
+ ref_data = AtomicData.to_AtomicDataDict(ref_data)
+ if ref_data.get(AtomicDataDict.ENERGY_EIGENVALUE_KEY) is None:
+ ref_data = self.eigenvalue(ref_data)
+
+ emin, emax = ref_data.get(AtomicDataDict.ENERGY_WINDOWS_KEY, (None, None))
+ band_min, band_max = ref_data.get(AtomicDataDict.BAND_WINDOW_KEY, (0, None))
+ eig_pred = data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] # (n_kpt, n_band)
+ eig_label = ref_data[AtomicDataDict.ENERGY_EIGENVALUE_KEY] # (n_kpt, n_band_dft/n_band)
- eig_pred_cut = th.reshape(eig_pred_cut, [-1,band_max-band_min])
- eig_label_cut = th.reshape(eig_label_cut, [-1,band_max-band_min])
+ norbs = eig_pred.shape[-1]
+ nbanddft = eig_label.shape[-1]
+ num_kp = eig_label.shape[-2]
- eig_pred_soft = torchsort.soft_sort(eig_pred_cut,regularization_strength=sort_strength)
- eig_label_soft = torchsort.soft_sort(eig_label_cut,regularization_strength=sort_strength)
-
-
- eig_pred_soft = th.reshape(eig_pred_soft, [batch_size, num_kp, num_bands])
- eig_label_soft = th.reshape(eig_label_soft, [batch_size, num_kp, num_bands])
-
- loss = criterion(eig_pred_soft,eig_label_soft)
-
- if gap_penalty:
- gap1 = eig_pred_soft[:,:,fermi_band+1] - eig_pred_soft[:,:,fermi_band]
- gap2 = eig_label_soft[:,:,fermi_band+1] - eig_label_soft[:,:,fermi_band]
- loss_gap = criterion(1.0/(gap1+eta), 1.0/(gap2+eta))
-
- if num_kp > 1:
- # randon choose nk_diff kps' eigenvalues to gen Delta eig.
- # nk_diff = max(nkps//4,1)
- nk_diff = num_kp
- k_diff_i = np.random.choice(num_kp,nk_diff,replace=False)
- k_diff_j = np.random.choice(num_kp,nk_diff,replace=False)
- while (k_diff_i==k_diff_j).all():
- k_diff_j = np.random.choice(num_kp, nk_diff, replace=False)
- eig_diff_lbl = eig_label_soft[:,k_diff_i,:] - eig_label_soft[:,k_diff_j,:]
- eig_ddiff_pred = eig_pred_soft[:,k_diff_i,:] - eig_pred_soft[:,k_diff_j,:]
- loss_diff = criterion(eig_diff_lbl, eig_ddiff_pred)
+ assert num_kp == eig_pred.shape[-2]
+ up_nband = min(norbs, nbanddft)
+
+ if band_max == None:
+ band_max = up_nband
+ else:
+ assert band_max <= up_nband
+
+ band_min = int(band_min)
+ band_max = int(band_max)
+
+ assert band_min < band_max
+ assert len(eig_pred.shape) == 2 and len(eig_label.shape) == 2
+
+ # 对齐eig_pred和eig_label
+ eig_pred_cut = eig_pred[:,band_min:band_max]
+ eig_label_cut = eig_label[:,band_min:band_max]
+
+
+ num_kp, num_bands = eig_pred_cut.shape
+
+ eig_pred_cut = eig_pred_cut - eig_pred_cut.reshape(-1).min()
+ eig_label_cut = eig_label_cut - eig_label_cut.reshape(-1).min()
+
+
+ if emax != None and emin != None:
+ mask_in = eig_label_cut.lt(emax) * eig_label_cut.gt(emin)
+ mask_out = eig_label_cut.gt(emax) + eig_label_cut.lt(emin)
+ elif emax != None:
+ mask_in = eig_label_cut.lt(emax)
+ mask_out = eig_label_cut.gt(emax)
+ elif emin != None:
+ mask_in = eig_label_cut.gt(emin)
+ mask_out = eig_label_cut.lt(emin)
+ else:
+ mask_in = None
+ mask_out = None
+
+ if mask_in is not None:
+ if torch.any(mask_in).item():
+ loss = mse_loss(eig_pred_cut.masked_select(mask_in), eig_label_cut.masked_select(mask_in))
+ if torch.any(mask_out).item():
+ loss = loss + self.eout_weight * mse_loss(eig_pred_cut.masked_select(mask_out), eig_label_cut.masked_select(mask_out))
+ else:
+ loss = mse_loss(eig_pred_cut, eig_label_cut)
+
+ if self.diff_on:
+ assert num_kp >= 1
+ # randon choose nk_diff kps' eigenvalues to gen Delta eig.
+ # nk_diff = max(nkps//4,1)
+ nk_diff = num_kp
+ k_diff_i = torch.randint(0, num_kp, (nk_diff,), device=self.device)
+ k_diff_j = torch.randint(0, num_kp, (nk_diff,), device=self.device)
+ while (k_diff_i==k_diff_j).all():
+ k_diff_j = torch.randint(0, num_kp, (nk_diff,), device=self.device)
+ if mask_in is not None:
+ eig_diff_lbl = eig_label_cut.masked_fill(mask_in, 0.)[:, k_diff_i,:] - eig_label_cut.masked_fill(mask_in, 0.)[:,k_diff_j,:]
+ eig_ddiff_pred = eig_pred_cut.masked_fill(mask_in, 0.)[:,k_diff_i,:] - eig_pred_cut.masked_fill(mask_in, 0.)[:,k_diff_j,:]
+ else:
+ eig_diff_lbl = eig_label_cut[:,k_diff_i,:] - eig_label_cut[:,k_diff_j,:]
+ eig_ddiff_pred = eig_pred_cut[:,k_diff_i,:] - eig_pred_cut[:,k_diff_j,:]
+ loss_diff = mse_loss(eig_diff_lbl, eig_ddiff_pred)
+
+ loss = loss + self.diff_weight * loss_diff
+
+ total_loss += loss
+
+ return total_loss / len(datalist)
+
+@Loss.register("hamil")
+class HamilLoss(nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ overlap: bool=False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+
+ super(HamilLoss, self).__init__()
+ self.loss1 = nn.L1Loss()
+ self.loss2 = nn.MSELoss()
+ self.overlap = overlap
+ self.device = device
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb", device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ def forward(self, data: AtomicDataDict, ref_data: AtomicDataDict):
+ # mask the data
+
+ # data[AtomicDataDict.NODE_FEATURES_KEY].masked_fill(~self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY]], 0.)
+ # data[AtomicDataDict.EDGE_FEATURES_KEY].masked_fill(~self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY]], 0.)
+
+ node_mean = ref_data[AtomicDataDict.NODE_FEATURES_KEY].mean(dim=-1, keepdim=True)
+ edge_mean = ref_data[AtomicDataDict.EDGE_FEATURES_KEY].mean(dim=-1, keepdim=True)
+ node_weight = 1/((ref_data[AtomicDataDict.NODE_FEATURES_KEY]-node_mean).norm(dim=-1, keepdim=True)+1e-5)
+ edge_weight = 1/((ref_data[AtomicDataDict.EDGE_FEATURES_KEY]-edge_mean).norm(dim=-1, keepdim=True)+1e-5)
- loss = (1*loss + 1*loss_diff)/2
-
- if gap_penalty:
- loss = loss + 0.1*loss_gap
-
- return loss
-
-
-
-def loss_spectral(criterion, eig_pred, eig_label, emin, emax, num_omega=None, sigma=0.1, **kwargs):
- ''' use eigenvalues to calculate electronic spectral functions and the use the prediced and label spectral
- function to calcualted loss .
- '''
- # calculate spectral fucntion A(k,w):
- assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
- if num_omega is None:
- num_omega = int((emax - emin)/sigma)
- omega = th.linspace(emin,emax,num_omega)
- min1 = th.min(eig_label)
- min2 = th.min(eig_pred)
- min1.detach()
- eig_label = eig_label-min1.detach()
- eig_pred = eig_pred - min2.detach()
- spectral_lbl = cal_spectral_func(eigenvalues= eig_label, omega=omega, sigma=sigma)
- spectral_pred = cal_spectral_func(eigenvalues= eig_pred, omega=omega, sigma=sigma)
- loss = criterion(spectral_lbl, spectral_pred)
+ pre = (node_weight*(data[AtomicDataDict.NODE_FEATURES_KEY]-node_mean))[self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()]]
+ tgt = (node_weight*(ref_data[AtomicDataDict.NODE_FEATURES_KEY]-node_mean))[self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()]]
+ onsite_loss = self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt))
+
+ pre = (edge_weight*(data[AtomicDataDict.EDGE_FEATURES_KEY]-edge_mean))[self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ tgt = (edge_weight*(ref_data[AtomicDataDict.EDGE_FEATURES_KEY]-edge_mean))[self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ hopping_loss = self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt))
+
+ if self.overlap:
+ over_mean = ref_data[AtomicDataDict.EDGE_OVERLAP_KEY].mean(dim=-1, keepdim=True)
+ over_weight = 1/((ref_data[AtomicDataDict.EDGE_OVERLAP_KEY]-over_mean).norm(dim=-1, keepdim=True)+1e-5)
+ pre = (over_weight*(data[AtomicDataDict.EDGE_OVERLAP_KEY]-over_mean))[self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ tgt = (over_weight*(ref_data[AtomicDataDict.EDGE_OVERLAP_KEY]-over_mean))[self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ hopping_loss += self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt))
+
+ return hopping_loss + onsite_loss
- return loss
-def gauss(x,sig,mu=0):
- ## gaussion fucntion
- #return th.exp(-(x-mu)**2/(2*sig**2)) * (1/((2*th.pi)**0.5*sig))
- return th.exp(-(x-mu)**2/(2*sig**2))
+@Loss.register("hamil_abs")
+class HamilLossAbs(nn.Module):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ overlap: bool=False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+ super(HamilLossAbs, self).__init__()
+ self.loss1 = nn.L1Loss()
+ self.loss2 = nn.MSELoss()
+ self.overlap = overlap
+ self.device = device
-def cal_spectral_func(eigenvalues,omega,sigma=0.1):
- nsnap, nkp, nband = eigenvalues.shape
- eigs_rsp = th.reshape(eigenvalues,[nsnap * nkp * nband,1])
- omega = th.reshape(omega,[1,-1])
- nomega = omega.shape[1]
- diffmax = omega - eigs_rsp
- gaussian_weight= gauss(diffmax,sigma)
- gaussian_weight_fmt = th.reshape(gaussian_weight,[nsnap, nkp, nband, nomega])
- # eigenvalues_fmt = np.reshape(eigenvalues,[nsnap, nkp, nband, 1])
- spectral_func = th.sum(gaussian_weight_fmt,dim=2)
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb", device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
- return spectral_func
+ def forward(self, data: AtomicDataDict, ref_data: AtomicDataDict):
+ # mask the data
+ # data[AtomicDataDict.NODE_FEATURES_KEY].masked_fill(~self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY]], 0.)
+ # data[AtomicDataDict.EDGE_FEATURES_KEY].masked_fill(~self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY]], 0.)
+
+ pre = data[AtomicDataDict.NODE_FEATURES_KEY][self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()]]
+ tgt = ref_data[AtomicDataDict.NODE_FEATURES_KEY][self.idp.mask_to_nrme[data[AtomicDataDict.ATOM_TYPE_KEY].flatten()]]
+ onsite_loss = 0.5*(self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt)))
+ pre = data[AtomicDataDict.EDGE_FEATURES_KEY][self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ tgt = ref_data[AtomicDataDict.EDGE_FEATURES_KEY][self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ hopping_loss = 0.5*(self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt)))
+
+ if self.overlap:
+ pre = data[AtomicDataDict.EDGE_OVERLAP_KEY][self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ tgt = ref_data[AtomicDataDict.EDGE_OVERLAP_KEY][self.idp.mask_to_erme[data[AtomicDataDict.EDGE_TYPE_KEY].flatten()]]
+ overlap_loss = 0.5*(self.loss1(pre, tgt) + torch.sqrt(self.loss2(pre, tgt)))
-def loss_proj_env(criterion, eig_pred, eig_label, ev_pred, proj_label, band_min=0, band_max=None):
- # eig_pred [nsnap, nkp, n_band_tb], eig_label [nsnap, nkp, n_band_dft]
- # ev_pred [nsnap, nkp, n_band_tb, norb_tb], ev_label [nsnap, nkp, n_band_dft, nprojorb_dft]
- # orbmap_pred [{atomtype-orbtype:index}*nsnap], orbmap_label [{atomtype-orbtype:index}*nsnap]
- # fit_band ["N-0s","B-0s"] like this
-
- norbs = eig_pred.shape[-1]
- nbanddft = eig_label.shape[-1]
- up_nband = min(norbs,nbanddft)
- if band_max is None:
- band_max = up_nband
- else:
- assert band_max <= up_nband
-
- band_min = int(band_min)
- band_max = int(band_max)
-
- nsnap, nkp, n_band_tb = eig_pred.shape
- wei = np.abs(ev_pred)**2
- wei_shp = wei[:,:,band_min:band_max,[0,3,1,2,5,8,6,7]]
- eig_pred_reshap = th.reshape(eig_pred[:,:,band_min:band_max], [nsnap,nkp, band_max - band_min,1])
- encoding_band_pred = th.sum(eig_pred_reshap * wei_shp,axis=2)
-
- eig_label_reshap = th.reshape(eig_label[:,:,band_min:band_max], [nsnap,nkp,band_max - band_min,1])
- wei_lbl_shp = proj_label[:,:,band_min:band_max]
- encoding_band_label = th.sum(eig_label_reshap * wei_lbl_shp,axis=2)
+ return (1/3) * (hopping_loss + onsite_loss + overlap_loss)
+ else:
+ return 0.5 * (onsite_loss + hopping_loss)
+
+
+class HamilLossAnalysis(object):
+ def __init__(
+ self,
+ basis: Dict[str, Union[str, list]]=None,
+ idp: Union[OrbitalMapper, None]=None,
+ overlap: bool=False,
+ dtype: Union[str, torch.dtype] = torch.float32,
+ decompose: bool = False,
+ device: Union[str, torch.device] = torch.device("cpu"),
+ **kwargs,
+ ):
+
+ super(HamilLossAnalysis, self).__init__()
+ self.overlap = overlap
+ self.device = device
+ self.decompose = decompose
+
+ if basis is not None:
+ self.idp = OrbitalMapper(basis, method="e3tb", device=self.device)
+ if idp is not None:
+ assert idp == self.idp, "The basis of idp and basis should be the same."
+ else:
+ assert idp is not None, "Either basis or idp should be provided."
+ self.idp = idp
+
+ if decompose:
+ self.e3h = E3Hamiltonian(idp=idp, decompose=decompose, overlap=False, device=device, dtype=dtype)
+ self.e3s = E3Hamiltonian(idp=idp, decompose=decompose, overlap=True, device=device, dtype=dtype)
- loss = criterion(encoding_band_pred, encoding_band_label)
+ def __call__(self, data: AtomicDataDict, ref_data: AtomicDataDict):
+ if self.decompose:
+ data = self.e3h(data)
+ ref_data = self.e3h(ref_data)
+ if self.overlap:
+ data = self.e3s(data)
+ ref_data = self.e3s(ref_data)
+
+
+ with torch.no_grad():
+ out = {}
+ err = data[AtomicDataDict.NODE_FEATURES_KEY] - ref_data[AtomicDataDict.NODE_FEATURES_KEY]
+ amp = ref_data[AtomicDataDict.NODE_FEATURES_KEY].abs()
+ mask = self.idp.mask_to_nrme[data["atom_types"].flatten()]
+ onsite = out.setdefault("onsite", {})
+ for at, tp in self.idp.chemical_symbol_to_type.items():
+ onsite_mask = mask[data["atom_types"].flatten().eq(tp)]
+ onsite_err = err[data["atom_types"].flatten().eq(tp)]
+ onsite_amp = amp[data["atom_types"].flatten().eq(tp)]
+ onsite_err = torch.stack([vec[ma] for vec, ma in zip(onsite_err, onsite_mask)])
+ onsite_amp = torch.stack([vec[ma] for vec, ma in zip(onsite_amp, onsite_mask)])
+ rmserr = (onsite_err**2).mean(dim=0).sqrt()
+ maerr = onsite_err.abs().mean(dim=0)
+ l1amp = onsite_amp.abs().mean(dim=0)
+ l2amp = (onsite_amp**2).mean(dim=0).sqrt()
+ onsite[at] = {
+ "rmse":(rmserr**2).mean().sqrt(),
+ "mae":maerr.mean(),
+ "rmse_per_block_element":rmserr,
+ "mae_per_block_element":maerr,
+ "l1amp":l1amp,
+ "l2amp":l2amp,
+ }
+
+ err = data[AtomicDataDict.EDGE_FEATURES_KEY] - ref_data[AtomicDataDict.EDGE_FEATURES_KEY]
+ amp = ref_data[AtomicDataDict.EDGE_FEATURES_KEY].abs()
+ mask = self.idp.mask_to_erme[data["edge_type"].flatten()]
+ hopping = out.setdefault("hopping", {})
+ for bt, tp in self.idp.bond_to_type.items():
+ hopping_mask = mask[data["edge_type"].flatten().eq(tp)]
+ hopping_err = err[data["edge_type"].flatten().eq(tp)]
+ hopping_amp = amp[data["edge_type"].flatten().eq(tp)]
+ hopping_err = torch.stack([vec[ma] for vec, ma in zip(hopping_err, hopping_mask)])
+ hopping_amp = torch.stack([vec[ma] for vec, ma in zip(hopping_amp, hopping_mask)])
+ rmserr = (hopping_err**2).mean(dim=0).sqrt()
+ maerr = hopping_err.abs().mean(dim=0)
+ l1amp = hopping_amp.abs().mean(dim=0)
+ l2amp = (hopping_amp**2).mean(dim=0).sqrt()
+ hopping[bt] = {
+ "rmse":(rmserr**2).mean().sqrt(),
+ "mae":maerr.mean(),
+ "rmse_per_block_element":rmserr,
+ "mae_per_block_element":maerr,
+ "l1amp":l1amp,
+ "l2amp":l2amp,
+ }
+
+ if self.overlap:
+ err = data[AtomicDataDict.EDGE_OVERLAP_KEY] - ref_data[AtomicDataDict.EDGE_OVERLAP_KEY]
+ amp = ref_data[AtomicDataDict.EDGE_OVERLAP_KEY].abs()
+ mask = self.idp.mask_to_erme[data["edge_type"].flatten()]
+ overlap = out.setdefault("overlap", {})
+
+ for bt, tp in self.idp.bond_to_type.items():
+ hopping_mask = mask[data["edge_type"].flatten().eq(tp)]
+ hopping_err = err[data["edge_type"].flatten().eq(tp)]
+ hopping_amp = amp[data["edge_type"].flatten().eq(tp)]
+ hopping_err = torch.stack([vec[ma] for vec, ma in zip(hopping_err, hopping_mask)])
+ hopping_amp = torch.stack([vec[ma] for vec, ma in zip(hopping_amp, hopping_mask)])
+ rmserr = (hopping_err**2).mean(dim=0).sqrt()
+ maerr = hopping_err.abs().mean(dim=0)
+ l1amp = hopping_amp.abs().mean(dim=0)
+ l2amp = (hopping_amp**2).mean(dim=0).sqrt()
+
+ overlap[bt] = {
+ "rmse":(rmserr**2).mean().sqrt(),
+ "mae":maerr.mean(),
+ "rmse_per_block_element":rmserr,
+ "mae_per_block_element":maerr,
+ "l1amp":l1amp,
+ "l2amp":l2amp,
+ }
- return loss
+ return out
\ No newline at end of file
diff --git a/dptb/nnops/tester.py b/dptb/nnops/tester.py
new file mode 100644
index 00000000..56da1eb3
--- /dev/null
+++ b/dptb/nnops/tester.py
@@ -0,0 +1,77 @@
+import torch
+import logging
+from dptb.utils.tools import get_lr_scheduler, \
+get_optimizer, j_must_have
+from dptb.nnops.base_tester import BaseTester
+from typing import Union, Optional
+from dptb.data import AtomicDataset, DataLoader, AtomicData
+from dptb.nn import build_model
+from dptb.nnops.loss import Loss
+
+log = logging.getLogger(__name__)
+#TODO: complete the log output for initilizing the trainer
+
+class Tester(BaseTester):
+
+ def __init__(
+ self,
+ test_options: dict,
+ common_options: dict,
+ model: torch.nn.Module,
+ test_datasets: AtomicDataset,
+ ) -> None:
+ super(Tester, self).__init__(dtype=common_options["dtype"], device=common_options["device"])
+
+ # init the object
+ self.model = model.to(self.device)
+ self.common_options = common_options
+ self.test_options = test_options
+
+ self.test_datasets = test_datasets
+
+ self.test_loader = DataLoader(dataset=self.train_datasets, batch_size=test_options["batch_size"], shuffle=False)
+
+ # loss function
+ self.test_lossfunc = Loss(**test_options["loss_options"]["test"], **common_options, idp=self.model.hamiltonian.idp)
+
+ def iteration(self, batch):
+ '''
+ conduct one step forward computation, used in train, test and validation.
+ '''
+ self.model.eval()
+ batch = batch.to(self.device)
+
+ # record the batch_info to help reconstructing sub-graph from the batch
+ batch_info = {
+ "__slices__": batch.__slices__,
+ "__cumsum__": batch.__cumsum__,
+ "__cat_dims__": batch.__cat_dims__,
+ "__num_nodes_list__": batch.__num_nodes_list__,
+ "__data_class__": batch.__data_class__,
+ }
+
+ batch = AtomicData.to_AtomicDataDict(batch)
+
+ batch_for_loss = batch.copy() # make a shallow copy in case the model change the batch data
+ #TODO: the rescale/normalization can be added here
+ batch = self.model(batch)
+
+ #TODO: this could make the loss function unjitable since t he batchinfo in batch and batch_for_loss does not necessarily
+ # match the torch.Tensor requiresment, should be improved further
+
+ batch.update(batch_info)
+ batch_for_loss.update(batch_info)
+
+ loss = self.train_lossfunc(batch, batch_for_loss)
+
+ state = {'field':'iteration', "test_loss": loss.detach()}
+ self.call_plugins(queue_name='iteration', time=self.iter, **state)
+ self.iter += 1
+
+ return loss.detach()
+
+ def epoch(self) -> None:
+
+ for ibatch in self.test_loader:
+ # iter with different structure
+ self.iteration(ibatch)
\ No newline at end of file
diff --git a/dptb/nnops/trainer.py b/dptb/nnops/trainer.py
new file mode 100644
index 00000000..1f009968
--- /dev/null
+++ b/dptb/nnops/trainer.py
@@ -0,0 +1,218 @@
+import torch
+import logging
+from dptb.utils.tools import get_lr_scheduler, \
+get_optimizer, j_must_have
+from dptb.nnops.base_trainer import BaseTrainer
+from typing import Union, Optional
+from dptb.data import AtomicDataset, DataLoader, AtomicData
+from dptb.nn import build_model
+from dptb.nnops.loss import Loss
+
+log = logging.getLogger(__name__)
+#TODO: complete the log output for initilizing the trainer
+
+class Trainer(BaseTrainer):
+
+ object_keys = ["lr_scheduler", "optimizer"]
+
+ def __init__(
+ self,
+ train_options: dict,
+ common_options: dict,
+ model: torch.nn.Module,
+ train_datasets: AtomicDataset,
+ reference_datasets: Union[AtomicDataset, None]=None,
+ validation_datasets: Union[AtomicDataset, None]=None,
+ ) -> None:
+ super(Trainer, self).__init__(dtype=common_options["dtype"], device=common_options["device"])
+
+ # init the object
+ self.model = model.to(self.device)
+ self.optimizer = get_optimizer(model_param=self.model.parameters(), **train_options["optimizer"])
+ self.lr_scheduler = get_lr_scheduler(optimizer=self.optimizer, **train_options["lr_scheduler"]) # add optmizer
+ self.common_options = common_options
+ self.train_options = train_options
+
+ self.train_datasets = train_datasets
+ self.use_reference = False
+ if reference_datasets is not None:
+ self.reference_datesets = reference_datasets
+ self.use_reference = True
+
+ if validation_datasets is not None:
+ self.validation_datasets = validation_datasets
+ self.use_validation = True
+ else:
+ self.use_validation = False
+
+ self.train_loader = DataLoader(dataset=self.train_datasets, batch_size=train_options["batch_size"], shuffle=True)
+
+ if self.use_reference:
+ self.reference_loader = DataLoader(dataset=self.reference_datesets, batch_size=train_options["ref_batch_size"], shuffle=True)
+
+ if self.use_validation:
+ self.validation_loader = DataLoader(dataset=self.validation_datasets, batch_size=train_options["val_batch_size"], shuffle=False)
+
+ # loss function
+ self.train_lossfunc = Loss(**train_options["loss_options"]["train"], **common_options, idp=self.model.hamiltonian.idp)
+ if self.use_validation:
+ self.validation_lossfunc = Loss(**train_options["loss_options"]["validation"], **common_options, idp=self.model.hamiltonian.idp)
+ if self.use_reference:
+ self.reference_lossfunc = Loss(**train_options["loss_options"]["reference"], **common_options, idp=self.model.hamiltonian.idp)
+
+ def iteration(self, batch, ref_batch=None):
+ '''
+ conduct one step forward computation, used in train, test and validation.
+ '''
+ self.model.train()
+ self.optimizer.zero_grad(set_to_none=True)
+ batch = batch.to(self.device)
+
+ # record the batch_info to help reconstructing sub-graph from the batch
+ batch_info = {
+ "__slices__": batch.__slices__,
+ "__cumsum__": batch.__cumsum__,
+ "__cat_dims__": batch.__cat_dims__,
+ "__num_nodes_list__": batch.__num_nodes_list__,
+ "__data_class__": batch.__data_class__,
+ }
+
+ batch = AtomicData.to_AtomicDataDict(batch)
+
+ batch_for_loss = batch.copy() # make a shallow copy in case the model change the batch data
+
+ batch = self.model(batch)
+
+ #TODO: this could make the loss function unjitable since t he batchinfo in batch and batch_for_loss does not necessarily
+ # match the torch.Tensor requiresment, should be improved further
+
+ batch.update(batch_info)
+ batch_for_loss.update(batch_info)
+
+ loss = self.train_lossfunc(batch, batch_for_loss)
+
+ if ref_batch is not None:
+ ref_batch = ref_batch.to(self.device) # AtomicData Type
+ batch_info = {
+ "__slices__": batch.__slices__,
+ "__cumsum__": batch.__cumsum__,
+ "__cat_dims__": batch.__cat_dims__,
+ "__num_nodes_list__": batch.__num_nodes_list__,
+ "__data_class__": batch.__data_class__,
+ }
+
+ ref_batch = AtomicData.to_AtomicDataDict(ref_batch) # AtomicDataDict Type
+ ref_batch_for_loss = ref_batch.copy()
+ ref_batch = self.model(ref_batch)
+
+ ref_batch.update(batch_info)
+ ref_batch_for_loss.update(batch_info)
+
+ loss += self.train_lossfunc(ref_batch, ref_batch_for_loss)
+
+ self.optimizer.zero_grad(set_to_none=True)
+ loss.backward()
+ #TODO: add clip large gradient
+ self.optimizer.step()
+
+ state = {'field':'iteration', "train_loss": loss.detach(), "lr": self.optimizer.state_dict()["param_groups"][0]['lr']}
+ self.call_plugins(queue_name='iteration', time=self.iter, **state)
+ self.iter += 1
+
+ #TODO: add EMA
+
+ return loss.detach()
+
+ @classmethod
+ def restart(
+ cls,
+ checkpoint: str,
+ train_datasets: AtomicDataset,
+ train_options: dict={},
+ common_options: dict={},
+ reference_datasets: Optional[AtomicDataset]=None,
+ validation_datasets: Optional[AtomicDataset]=None,
+ ):
+ """restart the training from a checkpoint, it does not support model options change."""
+
+ ckpt = torch.load(checkpoint)
+
+ run_opt = {
+ "restart": checkpoint,
+ }
+
+ model = build_model(run_opt, ckpt["config"]["model_options"], ckpt["config"]["common_options"])
+ if len(train_options) == 0:
+ train_options = ckpt["config"]["train_options"]
+ if len(common_options) == 0:
+ common_options = ckpt["config"]["common_options"]
+
+ # init trainer and load the trainer's states
+ trainer = cls(
+ model=model,
+ train_datasets=train_datasets,
+ reference_datasets=reference_datasets,
+ validation_datasets=validation_datasets,
+ train_options=train_options,
+ common_options=common_options,
+ )
+
+ trainer.ep = ckpt["epoch"]
+ trainer.iter = ckpt["iteration"]
+ trainer.stats = ckpt["stats"]
+
+ queues_name = list(trainer.plugin_queues.keys())
+ for unit in queues_name:
+ for plugin in trainer.plugin_queues[unit]:
+ plugin = (getattr(trainer, unit) + plugin[0], plugin[1], plugin[2])
+
+ for key in Trainer.object_keys:
+ item = getattr(trainer, key, None)
+ if item is not None:
+ item.load_state_dict(ckpt[key+"_state_dict"])
+
+ return trainer
+#
+
+ def epoch(self) -> None:
+
+ for ibatch in self.train_loader:
+ # iter with different structure
+ if self.use_reference:
+ self.iteration(ibatch, next(self.reference_loader))
+ else:
+ self.iteration(ibatch)
+
+ def update(self, **kwargs):
+ pass
+
+ def validation(self, fast=True):
+ with torch.no_grad():
+ loss = torch.scalar_tensor(0., dtype=self.dtype, device=self.device)
+ self.model.eval()
+
+ for batch in self.validation_loader:
+ batch = batch.to(self.device)
+
+ batch_info = {
+ "__slices__": batch.__slices__,
+ "__cumsum__": batch.__cumsum__,
+ "__cat_dims__": batch.__cat_dims__,
+ "__num_nodes_list__": batch.__num_nodes_list__,
+ "__data_class__": batch.__data_class__,
+ }
+
+ batch = AtomicData.to_AtomicDataDict(batch)
+
+ batch_for_loss = batch.copy()
+ batch = self.model(batch)
+
+ batch.update(batch_info)
+ batch_for_loss.update(batch_info)
+
+ loss += self.validation_lossfunc(batch, batch_for_loss)
+
+ if fast:
+ break
+
+ return loss
diff --git a/dptb/nnops/use_e3baseline.ipynb b/dptb/nnops/use_e3baseline.ipynb
new file mode 100644
index 00000000..7f33eb95
--- /dev/null
+++ b/dptb/nnops/use_e3baseline.ipynb
@@ -0,0 +1,3630 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/miniconda/envs/deeptb/lib/python3.8/site-packages/torch/jit/_check.py:181: UserWarning: The TorchScript type system doesn't support instance-level annotations on empty non-base types in `__init__`. Instead, either 1) use a type annotation in the class body, or 2) wrap the type in `torch.jit.Attribute`.\n",
+ " warnings.warn(\"The TorchScript type system doesn't support \"\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DPTB(\n",
+ " (embedding): E3BaseLineModelLocal(\n",
+ " (sh): SphericalHarmonics()\n",
+ " (onehot): OneHotAtomEncoding()\n",
+ " (init_layer): InitLayer(\n",
+ " (two_body_latent): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_embed_mlp): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (bessel): BesselBasis()\n",
+ " )\n",
+ " (layers): ModuleList(\n",
+ " (0): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (activation): Gate (142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 2178 paths | 2178 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (bn): BatchNorm (64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 142 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " (1): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (activation): Gate (142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 39396 paths | 39396 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 64x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 64x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 64x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 64x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 64x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 32x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 8x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 4x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 2x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 2x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (bn): BatchNorm (64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " (2): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (activation): Gate (142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 39396 paths | 39396 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 64x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 64x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 64x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 64x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 64x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 32x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 8x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 4x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 2x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 2x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (bn): BatchNorm (64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " (3): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (activation): Gate (142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 39396 paths | 39396 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 64x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 64x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 64x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 64x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 64x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 32x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 8x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 4x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 2x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 2x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (bn): BatchNorm (64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " (4): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (activation): Gate (142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 142x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 39396 paths | 39396 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 64x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 64x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 64x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 64x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 64x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 64x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 32x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 32x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 32x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 32x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 16x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 16x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 16x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 16x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 8x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 8x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 8x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 8x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 4x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 4x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 4x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 4x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 2x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 2x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 2x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 2x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x32 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x4 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x142 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x16 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (bn): BatchNorm (64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " (5): Layer(\n",
+ " (_env_weighter): Linear(1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e | 7 weights)\n",
+ " (_node_weighter): E3ElementLinear()\n",
+ " (_edge_weighter): E3ElementLinear()\n",
+ " (env_linears): Identity()\n",
+ " (lin_pre): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e | 5716 weights)\n",
+ " (activation): Gate (72x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e -> 10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e)\n",
+ " (tp): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 72x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e | 22988 paths | 22988 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 64x72 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 64x10 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 64x13 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 64x8 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 64x6 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 64x2 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 64x1 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 32x10 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 32x72 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 32x7 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 32x13 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 32x10 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 32x6 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 32x13 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 32x6 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 32x6 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 32x8 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 32x6 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 32x1 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 32x1 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 32x2 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 16x10 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 16x72 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 16x7 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 16x10 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 16x10 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 16x72 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 16x7 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 16x10 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 16x13 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 16x6 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 16x1 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 16x8 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 16x2 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 8x10 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 8x72 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 8x7 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 8x10 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (106): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (107): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (108): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (109): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (110): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (111): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (112): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (113): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (114): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (115): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (116): Parameter containing: [torch.float32 of size 4x13 (GPU 0)]\n",
+ " (117): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (118): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (119): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (120): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (121): Parameter containing: [torch.float32 of size 4x10 (GPU 0)]\n",
+ " (122): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (123): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (124): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (125): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (126): Parameter containing: [torch.float32 of size 4x72 (GPU 0)]\n",
+ " (127): Parameter containing: [torch.float32 of size 4x7 (GPU 0)]\n",
+ " (128): Parameter containing: [torch.float32 of size 4x13 (GPU 0)]\n",
+ " (129): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (130): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (131): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (132): Parameter containing: [torch.float32 of size 4x1 (GPU 0)]\n",
+ " (133): Parameter containing: [torch.float32 of size 4x10 (GPU 0)]\n",
+ " (134): Parameter containing: [torch.float32 of size 4x6 (GPU 0)]\n",
+ " (135): Parameter containing: [torch.float32 of size 4x8 (GPU 0)]\n",
+ " (136): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (137): Parameter containing: [torch.float32 of size 4x2 (GPU 0)]\n",
+ " (138): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (139): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (140): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (141): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (142): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (143): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (144): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (145): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (146): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (147): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (148): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (149): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (150): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (151): Parameter containing: [torch.float32 of size 2x10 (GPU 0)]\n",
+ " (152): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (153): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (154): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (155): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (156): Parameter containing: [torch.float32 of size 2x72 (GPU 0)]\n",
+ " (157): Parameter containing: [torch.float32 of size 2x7 (GPU 0)]\n",
+ " (158): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (159): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (160): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (161): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (162): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (106): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (107): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (108): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (109): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (110): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (111): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (112): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (113): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (114): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (115): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (116): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (117): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (118): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (119): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (120): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (121): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (122): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (123): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (124): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (125): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (126): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (127): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (128): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (129): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (130): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (131): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (132): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (133): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (134): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (135): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (136): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (137): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (138): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (139): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (140): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (141): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (142): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (143): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (144): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (145): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (146): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (147): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (148): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (149): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (150): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (151): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (152): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (153): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (154): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (155): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (156): Parameter containing: [torch.float32 of size 1x72 (GPU 0)]\n",
+ " (157): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (158): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (159): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (160): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (161): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (162): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (tp_out): SeparateWeightTensorProduct(\n",
+ " (tp): TensorProduct(10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e+1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e+1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e x 1x0e+1x1o+1x2e+1x3o+1x4e+1x5o+1x6e -> 10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e | 10971 paths | 10971 weights)\n",
+ " (weights1): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 10x10 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 10x10 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 10x13 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 10x8 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 10x6 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 10x2 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 10x1 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 10x10 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 10x10 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 10x7 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 10x13 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 10x10 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 10x6 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 10x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 10x13 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 10x6 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 10x6 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 10x8 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 10x2 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 10x2 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 10x6 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 10x1 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 10x1 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 10x2 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 7x7 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 7x10 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 7x6 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 7x7 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 7x13 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 7x6 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 7x6 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 7x8 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 7x2 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 7x6 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 7x6 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 7x1 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 7x2 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 7x2 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 7x1 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 7x1 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 6x7 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 6x10 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 6x7 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 13x13 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 13x10 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 13x8 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 13x10 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 13x7 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 13x13 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 13x10 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 13x8 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 13x2 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 13x2 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 13x13 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 13x1 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 13x1 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 13x8 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 13x2 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 13x2 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 13x6 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 13x1 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 13x1 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 8x10 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 8x10 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 8x7 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 8x10 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (106): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (107): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (108): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (109): Parameter containing: [torch.float32 of size 8x13 (GPU 0)]\n",
+ " (110): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (111): Parameter containing: [torch.float32 of size 8x6 (GPU 0)]\n",
+ " (112): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (113): Parameter containing: [torch.float32 of size 8x1 (GPU 0)]\n",
+ " (114): Parameter containing: [torch.float32 of size 8x8 (GPU 0)]\n",
+ " (115): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (116): Parameter containing: [torch.float32 of size 8x2 (GPU 0)]\n",
+ " (117): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (118): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (119): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (120): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (121): Parameter containing: [torch.float32 of size 6x7 (GPU 0)]\n",
+ " (122): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (123): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (124): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (125): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (126): Parameter containing: [torch.float32 of size 6x10 (GPU 0)]\n",
+ " (127): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (128): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (129): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (130): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (131): Parameter containing: [torch.float32 of size 6x7 (GPU 0)]\n",
+ " (132): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (133): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (134): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (135): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (136): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (137): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (138): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (139): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (140): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (141): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (142): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (143): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (144): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (145): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (146): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (147): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (148): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (149): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (150): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (151): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (152): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (153): Parameter containing: [torch.float32 of size 2x7 (GPU 0)]\n",
+ " (154): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (155): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (156): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (157): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (158): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (159): Parameter containing: [torch.float32 of size 2x10 (GPU 0)]\n",
+ " (160): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (161): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (162): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (163): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (164): Parameter containing: [torch.float32 of size 2x7 (GPU 0)]\n",
+ " (165): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (166): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (167): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (168): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (169): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (170): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (171): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (172): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (173): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (174): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (175): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (176): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (177): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (178): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (179): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (180): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (181): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (182): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (183): Parameter containing: [torch.float32 of size 6x10 (GPU 0)]\n",
+ " (184): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (185): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (186): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (187): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (188): Parameter containing: [torch.float32 of size 6x10 (GPU 0)]\n",
+ " (189): Parameter containing: [torch.float32 of size 6x7 (GPU 0)]\n",
+ " (190): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (191): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (192): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (193): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (194): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (195): Parameter containing: [torch.float32 of size 6x10 (GPU 0)]\n",
+ " (196): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (197): Parameter containing: [torch.float32 of size 6x8 (GPU 0)]\n",
+ " (198): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (199): Parameter containing: [torch.float32 of size 6x2 (GPU 0)]\n",
+ " (200): Parameter containing: [torch.float32 of size 6x13 (GPU 0)]\n",
+ " (201): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (202): Parameter containing: [torch.float32 of size 6x6 (GPU 0)]\n",
+ " (203): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (204): Parameter containing: [torch.float32 of size 6x1 (GPU 0)]\n",
+ " (205): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (206): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (207): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (208): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (209): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (210): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (211): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (212): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (213): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (214): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (215): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (216): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (217): Parameter containing: [torch.float32 of size 2x10 (GPU 0)]\n",
+ " (218): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (219): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (220): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (221): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (222): Parameter containing: [torch.float32 of size 2x10 (GPU 0)]\n",
+ " (223): Parameter containing: [torch.float32 of size 2x7 (GPU 0)]\n",
+ " (224): Parameter containing: [torch.float32 of size 2x13 (GPU 0)]\n",
+ " (225): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (226): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (227): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (228): Parameter containing: [torch.float32 of size 2x1 (GPU 0)]\n",
+ " (229): Parameter containing: [torch.float32 of size 2x10 (GPU 0)]\n",
+ " (230): Parameter containing: [torch.float32 of size 2x6 (GPU 0)]\n",
+ " (231): Parameter containing: [torch.float32 of size 2x8 (GPU 0)]\n",
+ " (232): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (233): Parameter containing: [torch.float32 of size 2x2 (GPU 0)]\n",
+ " (234): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (235): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (236): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (237): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (238): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (239): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (240): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (241): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (242): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (243): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (244): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (245): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (246): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (247): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (248): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (249): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (250): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (251): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (252): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (253): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (254): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (255): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (256): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (257): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (258): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (259): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (260): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (261): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (262): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (263): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (264): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (265): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (266): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (267): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (268): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (269): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (270): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (271): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (272): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (273): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (274): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (275): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (276): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (277): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (278): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (279): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (280): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (281): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (282): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (283): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (284): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (285): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (286): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (287): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (288): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (289): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (290): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (291): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (292): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (293): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (294): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (295): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (296): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (297): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (298): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (299): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (300): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (301): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (302): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (303): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (304): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (305): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (306): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (307): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (308): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (309): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (310): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (311): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (312): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (313): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (314): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (315): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (316): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (317): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (318): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (319): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (320): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (321): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (322): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (323): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (324): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (325): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (326): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (327): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (328): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (329): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (330): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (331): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (332): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (333): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (334): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (335): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (336): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (337): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (338): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (339): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (340): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (341): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (342): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (343): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (344): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (345): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (346): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (347): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (348): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (349): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (350): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (351): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (352): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (353): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (354): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (355): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (356): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (357): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (358): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (359): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (360): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (361): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (362): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (363): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (364): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (365): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (366): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (367): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (368): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (369): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (370): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (371): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (372): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (373): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (374): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (375): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (376): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (377): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (378): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (379): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (380): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (381): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (382): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (383): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (384): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (385): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (386): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (387): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (388): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (389): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (390): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (391): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (392): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (393): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (394): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (395): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (396): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (397): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (398): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (399): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (400): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (401): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (402): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (403): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (404): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (405): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (406): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (407): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (408): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (409): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (410): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (411): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (412): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (413): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (414): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (415): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (416): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (417): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (418): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (419): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (420): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (421): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (422): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (423): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (424): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (425): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (426): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (427): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (428): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (429): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (430): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (431): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (432): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (433): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (434): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (435): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (436): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (437): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (438): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (439): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (440): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (441): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (442): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (443): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (444): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (445): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (446): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (447): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (448): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (449): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (450): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (451): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (452): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (453): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (454): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (455): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (456): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (457): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (458): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (459): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (460): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (461): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (462): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (463): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (464): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (465): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (466): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (467): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (468): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (469): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (470): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (471): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (472): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (473): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (474): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (475): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (476): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (477): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (478): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (479): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (480): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (481): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (482): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (483): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (484): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (485): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (486): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (487): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (488): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (489): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (490): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (491): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (492): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (493): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (494): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (495): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (496): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (497): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (498): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (499): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (500): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (501): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (502): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (503): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (504): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (505): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (506): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (507): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (508): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (509): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (510): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (511): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (512): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (513): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (514): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (515): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (516): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (517): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (518): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (519): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (520): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (521): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (522): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (523): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (524): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (525): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (526): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (527): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (528): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (529): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (530): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (531): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (532): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (533): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (534): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (535): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (536): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (537): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (538): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (539): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (540): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (541): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (542): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (543): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (544): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (545): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (546): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (547): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (548): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (549): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (550): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (551): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (552): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (553): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (554): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (555): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (556): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (557): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (558): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (559): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (560): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (561): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (562): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (563): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (564): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (565): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (566): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (567): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (568): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (569): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (570): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (571): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (572): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (573): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (574): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (575): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (576): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (577): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (578): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (579): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (580): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (581): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (582): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (583): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (584): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (585): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (586): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (587): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (588): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (589): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (590): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (591): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (592): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (593): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (594): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (595): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (596): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (597): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (598): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (599): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (600): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (601): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (602): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (603): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (604): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (605): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (606): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (607): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (608): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (609): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (610): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (611): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (612): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " )\n",
+ " (weights2): ParameterList(\n",
+ " (0): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (1): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (2): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (3): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (4): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (5): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (6): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (7): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (8): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (9): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (10): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (11): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (12): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (13): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (14): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (15): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (16): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (17): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (18): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (19): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (20): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (21): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (22): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (23): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (24): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (25): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (26): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (27): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (28): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (29): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (30): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (31): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (32): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (33): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (34): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (35): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (36): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (37): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (38): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (39): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (40): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (41): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (42): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (43): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (44): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (45): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (46): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (47): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (48): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (49): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (50): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (51): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (52): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (53): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (54): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (55): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (56): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (57): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (58): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (59): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (60): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (61): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (62): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (63): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (64): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (65): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (66): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (67): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (68): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (69): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (70): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (71): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (72): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (73): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (74): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (75): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (76): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (77): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (78): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (79): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (80): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (81): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (82): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (83): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (84): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (85): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (86): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (87): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (88): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (89): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (90): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (91): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (92): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (93): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (94): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (95): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (96): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (97): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (98): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (99): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (100): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (101): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (102): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (103): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (104): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (105): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (106): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (107): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (108): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (109): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (110): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (111): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (112): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (113): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (114): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (115): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (116): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (117): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (118): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (119): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (120): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (121): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (122): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (123): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (124): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (125): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (126): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (127): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (128): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (129): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (130): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (131): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (132): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (133): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (134): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (135): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (136): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (137): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (138): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (139): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (140): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (141): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (142): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (143): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (144): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (145): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (146): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (147): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (148): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (149): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (150): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (151): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (152): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (153): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (154): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (155): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (156): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (157): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (158): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (159): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (160): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (161): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (162): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (163): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (164): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (165): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (166): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (167): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (168): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (169): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (170): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (171): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (172): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (173): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (174): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (175): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (176): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (177): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (178): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (179): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (180): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (181): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (182): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (183): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (184): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (185): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (186): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (187): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (188): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (189): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (190): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (191): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (192): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (193): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (194): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (195): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (196): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (197): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (198): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (199): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (200): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (201): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (202): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (203): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (204): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (205): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (206): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (207): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (208): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (209): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (210): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (211): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (212): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (213): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (214): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (215): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (216): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (217): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (218): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (219): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (220): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (221): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (222): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (223): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (224): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (225): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (226): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (227): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (228): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (229): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (230): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (231): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (232): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (233): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (234): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (235): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (236): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (237): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (238): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (239): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (240): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (241): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (242): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (243): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (244): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (245): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (246): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (247): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (248): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (249): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (250): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (251): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (252): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (253): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (254): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (255): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (256): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (257): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (258): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (259): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (260): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (261): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (262): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (263): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (264): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (265): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (266): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (267): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (268): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (269): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (270): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (271): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (272): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (273): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (274): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (275): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (276): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (277): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (278): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (279): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (280): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (281): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (282): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (283): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (284): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (285): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (286): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (287): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (288): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (289): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (290): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (291): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (292): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (293): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (294): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (295): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (296): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (297): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (298): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (299): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (300): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (301): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (302): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (303): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (304): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (305): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (306): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (307): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (308): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (309): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (310): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (311): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (312): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (313): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (314): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (315): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (316): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (317): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (318): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (319): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (320): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (321): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (322): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (323): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (324): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (325): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (326): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (327): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (328): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (329): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (330): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (331): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (332): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (333): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (334): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (335): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (336): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (337): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (338): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (339): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (340): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (341): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (342): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (343): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (344): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (345): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (346): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (347): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (348): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (349): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (350): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (351): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (352): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (353): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (354): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (355): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (356): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (357): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (358): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (359): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (360): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (361): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (362): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (363): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (364): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (365): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (366): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (367): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (368): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (369): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (370): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (371): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (372): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (373): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (374): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (375): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (376): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (377): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (378): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (379): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (380): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (381): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (382): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (383): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (384): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (385): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (386): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (387): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (388): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (389): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (390): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (391): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (392): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (393): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (394): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (395): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (396): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (397): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (398): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (399): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (400): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (401): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (402): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (403): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (404): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (405): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (406): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (407): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (408): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (409): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (410): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (411): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (412): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (413): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (414): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (415): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (416): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (417): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (418): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (419): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (420): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (421): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (422): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (423): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (424): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (425): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (426): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (427): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (428): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (429): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (430): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (431): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (432): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (433): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (434): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (435): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (436): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (437): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (438): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (439): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (440): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (441): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (442): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (443): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (444): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (445): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (446): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (447): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (448): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (449): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (450): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (451): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (452): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (453): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (454): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (455): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (456): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (457): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (458): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (459): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (460): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (461): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (462): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (463): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (464): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (465): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (466): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (467): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (468): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (469): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (470): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (471): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (472): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (473): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (474): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (475): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (476): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (477): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (478): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (479): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (480): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (481): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (482): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (483): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (484): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (485): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (486): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (487): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (488): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (489): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (490): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (491): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (492): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (493): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (494): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (495): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (496): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (497): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (498): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (499): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (500): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (501): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (502): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (503): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (504): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (505): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (506): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (507): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (508): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (509): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (510): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (511): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (512): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (513): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (514): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (515): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (516): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (517): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (518): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (519): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (520): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (521): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (522): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (523): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (524): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (525): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (526): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (527): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (528): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (529): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (530): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (531): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (532): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (533): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (534): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (535): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (536): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (537): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (538): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (539): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (540): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (541): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (542): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (543): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (544): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (545): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (546): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (547): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (548): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (549): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (550): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (551): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (552): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (553): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (554): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (555): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (556): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (557): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (558): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (559): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (560): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (561): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (562): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (563): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (564): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (565): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (566): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (567): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (568): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (569): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (570): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (571): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (572): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (573): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (574): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (575): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (576): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (577): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (578): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (579): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (580): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (581): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (582): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (583): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (584): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (585): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (586): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (587): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (588): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (589): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (590): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (591): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (592): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (593): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (594): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (595): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (596): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (597): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (598): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (599): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (600): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (601): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (602): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (603): Parameter containing: [torch.float32 of size 1x8 (GPU 0)]\n",
+ " (604): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (605): Parameter containing: [torch.float32 of size 1x2 (GPU 0)]\n",
+ " (606): Parameter containing: [torch.float32 of size 1x10 (GPU 0)]\n",
+ " (607): Parameter containing: [torch.float32 of size 1x7 (GPU 0)]\n",
+ " (608): Parameter containing: [torch.float32 of size 1x13 (GPU 0)]\n",
+ " (609): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (610): Parameter containing: [torch.float32 of size 1x6 (GPU 0)]\n",
+ " (611): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " (612): Parameter containing: [torch.float32 of size 1x1 (GPU 0)]\n",
+ " )\n",
+ " )\n",
+ " (lin_post): Linear(10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e -> 10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e | 600 weights)\n",
+ " (bn): BatchNorm (10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e, eps=1e-05, momentum=0.1)\n",
+ " (linear_res): Linear(64x0e+32x1o+16x2e+16x3o+8x4e+4x5o+2x6e -> 10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e | 1354 weights)\n",
+ " (latents): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (env_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (node_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " (edge_embed_mlps): ScalarMLPFunction(\n",
+ " (_forward): RecursiveScriptModule(original_name=GraphModule)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (out_edge): Linear(10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e -> 1x0e+1x0e+1x0e+1x1o+1x1o+1x1o+1x1o+1x2e+1x2e+1x2e+1x2e+1x3o+1x3o+1x0e+1x1e+1x2e+1x0e+1x1e+1x2e+1x0e+1x1e+1x2e+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x2e+1x3e+1x4e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x1o+1x2o+1x3o+1x4o+1x5o+1x1o+1x2o+1x3o+1x4o+1x5o+1x0e+1x1e+1x2e+1x3e+1x4e+1x5e+1x6e | 600 weights)\n",
+ " (out_node): Linear(10x0e+10x1o+7x1e+6x2o+13x2e+8x3o+6x3e+2x4o+6x4e+2x5o+1x5e+1x6e -> 1x0e+1x0e+1x0e+1x1o+1x1o+1x1o+1x1o+1x2e+1x2e+1x2e+1x2e+1x3o+1x3o+1x0e+1x1e+1x2e+1x0e+1x1e+1x2e+1x0e+1x1e+1x2e+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x1o+1x2o+1x3o+1x2e+1x3e+1x4e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x0e+1x1e+1x2e+1x3e+1x4e+1x1o+1x2o+1x3o+1x4o+1x5o+1x1o+1x2o+1x3o+1x4o+1x5o+1x0e+1x1e+1x2e+1x3e+1x4e+1x5e+1x6e | 600 weights)\n",
+ " )\n",
+ " (node_prediction_h): E3PerSpeciesScaleShift()\n",
+ " (edge_prediction_h): E3PerEdgeSpeciesScaleShift()\n",
+ " (hamiltonian): E3Hamiltonian()\n",
+ ")"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from dptb.nnops.trainer import Trainer\n",
+ "from dptb.data import ABACUSInMemoryDataset\n",
+ "from dptb.data.transforms import OrbitalMapper\n",
+ "from dptb.nn import build_model\n",
+ "\n",
+ "from dptb.plugins.monitor import TrainLossMonitor, LearningRateMonitor\n",
+ "from dptb.plugins.train_logger import Logger\n",
+ "from dptb.plugins.plugins import Saver\n",
+ "import heapq\n",
+ "import logging\n",
+ "from dptb.utils.loggers import set_log_handles\n",
+ "\n",
+ "common_options = {\n",
+ " \"basis\": {\n",
+ " \"Ga\": \"2s2p2d1f\",\n",
+ " \"N\": \"2s2p1d\"\n",
+ " },\n",
+ " # \"basis\":{\"Mo\":\"3s2p2d\", \"S\":\"2s2p1d\"},\n",
+ " \"device\": \"cuda:0\",\n",
+ " \"dtype\": \"float32\",\n",
+ " \"overlap\": False,\n",
+ "}\n",
+ "\n",
+ "root = \"/share/semicond/lmp_abacus/abacus_hse_data/GaN/prod-gan/GaN/sys-000/processed_GaN_pbe\"\n",
+ "train_dataset = ABACUSInMemoryDataset(\n",
+ " root=root,\n",
+ " preprocess_dir=\"/share/semicond/lmp_abacus/abacus_hse_data/GaN/prod-gan/GaN/sys-000/processed_GaN_pbe\",\n",
+ " AtomicData_options={\n",
+ " \"r_max\": 8.0,\n",
+ " \"er_max\": None,\n",
+ " \"oer_max\": None,\n",
+ " \"pbc\": True,\n",
+ " },\n",
+ " type_mapper=OrbitalMapper(basis=common_options[\"basis\"]),\n",
+ ")\n",
+ "\n",
+ "train_options = {\n",
+ " \"seed\": 12070,\n",
+ " \"num_epoch\": 4000,\n",
+ " \"batch_size\": 1,\n",
+ " \"optimizer\": {\n",
+ " \"lr\": 0.01,\n",
+ " \"type\": \"Adam\",\n",
+ " },\n",
+ " \"lr_scheduler\": {\n",
+ " \"type\": \"exp\",\n",
+ " \"gamma\": 0.9995\n",
+ " },\n",
+ " \"loss_options\":{\n",
+ " \"train\":{\"method\": \"eigvals\"}\n",
+ " },\n",
+ " \"save_freq\": 10,\n",
+ " \"validation_freq\": 10,\n",
+ " \"display_freq\": 1\n",
+ "}\n",
+ "\n",
+ "run_opt = {\n",
+ " \"init_model\": \"/root/e3/local/refine_2_6lmax_6l/checkpoint/dptb.iter1001.pth\",\n",
+ " \"restart\": None,\n",
+ " \"freeze\": False,\n",
+ " \"train_soc\": False,\n",
+ " \"log_path\": None,\n",
+ " \"log_level\": None\n",
+ " }\n",
+ "\n",
+ "model_option = {\n",
+ " \"embedding\": {\n",
+ " \"method\": \"e3baseline_local\",\n",
+ " \"r_max\": {\"Ga\":8.1, \"N\":7.1},\n",
+ " \"irreps_hidden\": \"32x0e+32x1o+16x2e+16x3o+16x4e+16x5o+8x6e\",\n",
+ " \"lmax\": 4,\n",
+ " \"n_layers\": 4,\n",
+ " \"n_radial_basis\": 18,\n",
+ " \"env_embed_multiplicity\":1,\n",
+ " \"avg_num_neighbors\": 63,\n",
+ " \"latent_kwargs\": {\n",
+ " \"mlp_latent_dimensions\": [128, 128, 256],\n",
+ " \"mlp_nonlinearity\": \"silu\",\n",
+ " \"mlp_initialization\": \"uniform\"\n",
+ " }\n",
+ " },\n",
+ " \"prediction\":{\n",
+ " \"method\": \"e3tb\",\n",
+ " \"scales_trainable\":True,\n",
+ " \"shifts_trainable\":True\n",
+ " }\n",
+ "}\n",
+ "\n",
+ "model = build_model(run_opt, {}, common_options)\n",
+ "model.to(common_options[\"device\"])\n",
+ "\n",
+ "model.eval()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "993467\n"
+ ]
+ }
+ ],
+ "source": [
+ "np = 0\n",
+ "for p in model.parameters():\n",
+ " np += p.view(-1).shape[0]\n",
+ "\n",
+ "print(np)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.data import AtomicData\n",
+ "from dptb.data.dataloader import DataLoader\n",
+ "import torch\n",
+ "\n",
+ "loader = DataLoader(train_dataset, batch_size=10, shuffle=True, num_workers=0)\n",
+ "\n",
+ "for data in loader:\n",
+ " ref_data = AtomicData.to_AtomicDataDict(data.to(\"cuda:0\"))\n",
+ " break\n",
+ "# ref_data = AtomicData.to_AtomicDataDict(train_dataset[dN].to(\"cuda:0\"))\n",
+ "with torch.no_grad():\n",
+ " data = model(ref_data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.nnops.loss import HamilLossAnalysis\n",
+ "\n",
+ "ana = HamilLossAnalysis(idp=model.idp, device=model.device, decompose=True)\n",
+ "\n",
+ "ana_result = ana(data, ref_data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "rmse err for bond N-N: 0.021915080025792122 \t mae err for bond N-N: 0.008099161088466644\n",
+ "rmse err for bond N-Ga: 0.04044164717197418 \t mae err for bond N-Ga: 0.017163095995783806\n",
+ "rmse err for bond Ga-N: 0.03134715557098389 \t mae err for bond Ga-N: 0.009912804700434208\n",
+ "rmse err for bond Ga-Ga: 0.076223224401474 \t mae err for bond Ga-Ga: 0.03573114797472954\n",
+ "rmse err for atom N: 0.13477067649364471 \t mae err for bond N: 0.03793104737997055\n",
+ "rmse err for atom Ga: 0.19352763891220093 \t mae err for bond Ga: 0.052813541144132614\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABkoAAAEpCAYAAADccn5yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUX0lEQVR4nO3deVxV1f7/8TeDDA7ggIA4gbNeB0yUcMKKBLOB8jqlgujV201uKjdL+qpolqilYWqilUOl6bXUBssycqikTM3KsfRqelNALSUxQWH//ujHuR05KIfpAOf1fDz2Q/faa+/92YfN4pz9OWstB8MwDAEAAAAAAAAAANghR1sHAAAAAAAAAAAAYCskSgAAAAAAAAAAgN0iUQIAAAAAAAAAAOwWiRIAAAAAAAAAAGC3SJQAAAAAAAAAAAC7RaIEAAAAAAAAAADYLRIlAAAAAAAAAADAbpEoAQAAAAAAAAAAdotECQAAAAAAAAAAsFskSgAAAIAKbuXKlXJwcNDJkyfNyp977jk1a9ZMTk5OCgwMlCT5+/tr5MiR5R5jZZSenq6//vWvqlevnhwcHJSUlGSx3smTJ+Xg4KDnn3++fAO8BQcHB02fPt3WYQAAAACVHokSAAAAoBL6+OOP9cQTT6hHjx5asWKFZs2aZeuQKp2JEyfqo48+Unx8vF5//XVFRETYOqRSd+bMGU2fPl379++3dSglkp2drYULF6pnz56qU6eOXFxc5Ofnp/vvv19vvvmmcnNzS+1c+YkxBwcHvf322wW2T58+XQ4ODjp//nypnRMAAAC25WzrAAAAAADc3IgRIzRkyBC5urqayj799FM5Ojrq1VdflYuLi6n86NGjcnTk+1BF8emnn+qBBx7Q448/butQysyZM2c0Y8YM+fv7m3odVTbnzp1Tv379tHfvXoWHh2vKlCmqW7eu0tLS9Mknn+jhhx/WsWPHNHXq1FI/99NPP62HHnpIDg4OpX5sAAAAVBwkSgAAAGBzWVlZqlGjhq3DqLCcnJzk5ORkVpaRkSF3d3ezJIkks2SKLV25ckXVq1cvUH79+nXl5eUViNsapXW/ZGRkqHbt2iU+DsrWiBEj9M033+jtt9/WQw89ZLYtPj5ee/bs0dGjR0v9vIGBgdq/f782btxY4LwAAACoWviqGQAAAMpV/rA1hw4d0sMPP6w6deqoZ8+ekv6YX+Pee+/V9u3bFRQUJHd3d3Xo0EHbt2+XJG3YsEEdOnSQm5ubunTpom+++abA8Y8cOaK//vWvqlu3rtzc3BQUFKR33323SLGtXbtWXbp0Ua1ateTh4aEOHTpowYIFpu35c4Xs3LlTf//731WvXj15eHgoKipKv/76a4Hjffjhh+rVq5dq1KihWrVqqX///jp48KDFmAcNGqT69evL3d1drVu31v/93/8VOG/+HCUODg5asWKFsrKyTEMErVy50vQa3jhHycWLFzVx4kT5+/vL1dVVjRo1UlRUVJGGDnrjjTfUpUsXubu7q27duhoyZIhOnz5tVqdPnz5q37699u7dq969e6t69ep66qmnzOb2SEpKUvPmzeXq6qpDhw5J+qNHR/7rU7t2bT3wwAM6fPiw2bFvdr8U5j//+Y8GDhyounXrqnr16rr99tu1efPmAq+nYRhavHix6TUsihdeeEFNmzaVu7u7QkNDdeDAgQJ1rLmuY8eOaeTIkapdu7Y8PT0VExOjK1eumNXNzs7WxIkTVb9+fdWqVUv333+//vvf/94y1u3bt6tr166SpJiYGLN7JSEhQdWqVdO5c+cK7Dd27FjVrl1bV69elfS/38uPP/5YgYGBcnNzU7t27bRhw4YC+168eFETJkxQ48aN5erqqhYtWmjOnDnKy8szq3f27FkdOXJE165du+k1pKam6qOPPtLYsWMLTVYEBQVp2LBhpvWcnBxNmzZNXbp0kaenp2rUqKFevXpp27ZtN3/BbjBkyBC1atVKTz/9tAzDsGpfAAAAVC4kSgAAAGATAwcO1JUrVzRr1iyNGTPGVH7s2DE9/PDDuu+++5SYmKhff/1V9913n1avXq2JEydq+PDhmjFjho4fP65BgwaZPYA9ePCgbr/9dh0+fFiTJ0/WvHnzVKNGDUVGRmrjxo03jWfr1q0aOnSo6tSpozlz5mj27Nnq06ePvvjiiwJ1Y2NjdfjwYU2fPl1RUVFavXq1IiMjzR6mvv766+rfv79q1qypOXPmaOrUqTp06JB69uxpNin7d999p+DgYH366acaM2aMFixYoMjISL333nuFxvr666+rV69ecnV11euvv67XX39dvXv3tlj38uXL6tWrlxYuXKi+fftqwYIFeuSRR3TkyJFbPmx/9tlnFRUVpZYtW2r+/PmaMGGCUlJS1Lt3b128eNGs7oULF9SvXz8FBgYqKSlJd9xxh2nbihUrtHDhQo0dO1bz5s1T3bp19cknnyg8PFwZGRmaPn264uLitGvXLvXo0aPApPVS4ffLjdLT09W9e3d99NFHevTRR/Xss8/q6tWruv/++033QO/evfX6669Lku6++27Ta3grr732ml588UWNGzdO8fHxOnDggO68806lp6eb6lh7XYMGDdJvv/2mxMREDRo0SCtXrtSMGTPM6vztb39TUlKS+vbtq9mzZ6tatWrq37//LeNt27atnn76aUl/JD/+fK+MGDFC169f17p168z2ycnJ0VtvvaUBAwbIzc3NVP7jjz9q8ODB6tevnxITE+Xs7KyBAwdq69atpjpXrlxRaGio3njjDUVFRenFF19Ujx49FB8fr7i4OLPzxMfHq23btvr5559veg35vwfDhw+/5fXmy8zM1CuvvKI+ffpozpw5mj59us6dO6fw8HCr5mpxcnLSlClT9O23396y/QAAAEAlZwAAAADlKCEhwZBkDB06tMC2pk2bGpKMXbt2mco++ugjQ5Lh7u5u/PTTT6bypUuXGpKMbdu2mcruuusuo0OHDsbVq1dNZXl5eUb37t2Nli1b3jSu8ePHGx4eHsb169cLrbNixQpDktGlSxcjJyfHVD537lxDkvHOO+8YhmEYv/32m1G7dm1jzJgxZvunpaUZnp6eZuW9e/c2atWqZXZt+XHfeN4TJ06YyqKjo40aNWoUiLFp06ZGdHS0aX3atGmGJGPDhg0F6v75HDc6efKk4eTkZDz77LNm5d9//73h7OxsVh4aGmpIMpKTk83qnjhxwpBkeHh4GBkZGWbbAgMDDW9vb+PChQumsm+//dZwdHQ0oqKiTGU3u18smTBhgiHJ+Oyzz0xlv/32mxEQEGD4+/sbubm5pnJJxrhx4255zPzrcHd3N/773/+ayr/66itDkjFx4sRiX9eoUaPMzvXggw8a9erVM63v37/fkGQ8+uijZvUefvhhQ5KRkJBw09i//vprQ5KxYsWKAttCQkKM4OBgs7INGzYU+L3K/718++23TWWXLl0yGjRoYHTu3NlUNnPmTKNGjRrGDz/8YHbMyZMnG05OTsapU6dMZdHR0QXuaUsefPBBQ5Jx8eJFs/Lff//dOHfunGn59ddfTduuX79uZGdnm9X/9ddfDR8fnwKvtyX5P+/nnnvOuH79utGyZUujU6dOpt+X/J/duXPnbnksAAAAVA70KAEAAIBNPPLIIxbL27Vrp5CQENN6cHCwJOnOO+9UkyZNCpT/5z//kST98ssv+vTTT03f0D9//rzOnz+vCxcuKDw8XD/++ONNv71eu3ZtZWVlmX1DvjBjx45VtWrVTOv/+Mc/5OzsrA8++EDSH71TLl68qKFDh5riOH/+vJycnBQcHGwaAujcuXPauXOnRo0aZXZtkkpt8ui3335bnTp10oMPPlhg283OsWHDBuXl5WnQoEFm1+Dr66uWLVsWGMbI1dVVMTExFo81YMAA1a9f37R+9uxZ7d+/XyNHjlTdunVN5R07dtTdd99teh3/rLD75UYffPCBunXrZjY8V82aNTV27FidPHnSNOxXcURGRqphw4am9W7duik4ONgUb2lcV69evXThwgVlZmaarkeSHnvsMbN6EyZMKPZ15IuKitJXX32l48ePm8pWr16txo0bKzQ01Kyun5+f2T2UP+TcN998o7S0NEnS+vXr1atXL9WpU8fsngkLC1Nubq527txp2n/lypUyDEP+/v43jTH/dahZs6ZZeXJysurXr29a/vzzdnJyMs2Bk5eXp19++UXXr19XUFCQ9u3bZ8UrZN6rZNOmTVbtCwAAgMqDRAkAAABsIiAgwGL5jQkDT09PSVLjxo0tlufPDXLs2DEZhqGpU6eaPUCtX7++EhISJP0xeXdhHn30UbVq1Ur9+vVTo0aNNGrUKG3ZssVi3ZYtW5qt16xZUw0aNDANrfTjjz9K+iO5c2MsH3/8sSmO/CRP+/btC42rpI4fP16s4//4448yDEMtW7YscA2HDx8u8Fo2bNiw0Anab/xZ//TTT5Kk1q1bF6jbtm1bnT9/XllZWTc9RmF++umnQo/753MXx40/d0lq1aqV6edenOu68X6vU6eOpP/d1z/99JMcHR3VvHlzs3qWzmGtwYMHy9XVVatXr5YkXbp0Se+//76GDRtWIInWokWLAmWtWrWSJLP7fsuWLQXul7CwMEk3//0rTK1atST9MYTcnw0YMEBbt27V1q1b1bFjxwL7rVq1Sh07dpSbm5vq1aun+vXra/Pmzbp06ZKpzrlz55SWlmZabjxHvmHDhqlFixbMVQIAAFCFOds6AAAAANgnd3d3i+VOTk5Wlec/uMyfq+Txxx9XeHi4xbotWrQoNB5vb2/t379fH330kT788EN9+OGHWrFihaKiorRq1apC97MkP5bXX39dvr6+BbY7O1f8t+F5eXlycHDQhx9+aPG1v/Eb/oX9PG+1rahK4xgV0a3u67JUp04d3XvvvVq9erWmTZumt956S9nZ2VbNB/JneXl5uvvuu/XEE09Y3J6fWLFGmzZtJEkHDhxQjx49TOWNGzc2JU/ze7Dke+ONNzRy5EhFRkZq0qRJ8vb2lpOTkxITE816z3Tt2tUscZaQkKDp06cXiCG/V8nIkSP1zjvvWH0NAAAAqPgq/ic0AAAAoAiaNWsmSapWrZrpG+zWcnFx0X333af77rtPeXl5evTRR7V06VJNnTrVLMny448/mk1WfvnyZZ09e1b33HOPJJm+/e/t7X3TWPJjPnDgQLHiLYrmzZsX6/jNmzeXYRgKCAgo1gPum2natKkk6ejRowW2HTlyRF5eXqpRo0axj13Ycf987uLI7yn0Zz/88INp+KiyuK6mTZsqLy9Px48fN+tFYukcltxqCLeoqCg98MAD+vrrr7V69Wp17txZf/nLXwrUy++x9efj/fDDD5Jkuv7mzZvr8uXLxf79s+Tee+/V7NmztXr1arNEyc289dZbatasmTZs2GAWb37PsnyrV6/W77//blrP/320ZPjw4XrmmWc0Y8YM3X///VZeBQAAACo6ht4CAABAleDt7a0+ffpo6dKlOnv2bIHt586du+n+Fy5cMFt3dHQ0DemTnZ1ttm3ZsmW6du2aaX3JkiW6fv26+vXrJ0kKDw+Xh4eHZs2aZVbvxljq16+v3r17a/ny5Tp16pRZndLqUTBgwAB9++232rhxY4FtNzvHQw89JCcnJ82YMaNAPcMwCrxe1mjQoIECAwO1atUqXbx40VR+4MABffzxx6aEU3Hcc8892r17t1JTU01lWVlZWrZsmfz9/dWuXbtiH3vTpk1m89zs3r1bX331lennXhbXlX/sF1980aw8KSmpSPvnJ2b+HM+Nx/fy8tKcOXO0Y8eOQnuTnDlzxuweyszM1GuvvabAwEBTr6lBgwYpNTVVH330UYH9L168qOvXr5vWz549qyNHjlj8/fizHj166O6779ayZcsK7c1x4/2Z30vnz+VfffWV2T2Rf+ywsDDTcrNESX6vkv379+vdd9+9acwAAACofOhRAgAAgCpj8eLF6tmzpzp06KAxY8aoWbNmSk9PV2pqqv773//q22+/LXTfv/3tb/rll1905513qlGjRvrpp5+0cOFCBQYGmua3yJeTk6O77rpLgwYN0tGjR/XSSy+pZ8+epm+ae3h4aMmSJRoxYoRuu+02DRkyRPXr19epU6e0efNm9ejRQ4sWLZL0xwPwnj176rbbbtPYsWMVEBCgkydPavPmzdq/f3+JX5NJkybprbfe0sCBAzVq1Ch16dJFv/zyi959910lJyerU6dOFvdr3ry5nnnmGcXHx+vkyZOKjIxUrVq1dOLECW3cuFFjx47V448/Xuy4nnvuOfXr108hISEaPXq0fv/9dy1cuFCenp4Whz8qqsmTJ+vNN99Uv3799Nhjj6lu3bpatWqVTpw4obfffluOjsX/rliLFi3Us2dP/eMf/1B2draSkpJUr149s6GmSvu6AgMDNXToUL300ku6dOmSunfvrpSUFB07dqxI+zdv3ly1a9dWcnKyatWqpRo1aig4ONg050u1atU0ZMgQLVq0SE5OTho6dKjF47Rq1UqjR4/W119/LR8fHy1fvlzp6elasWKFqc6kSZP07rvv6t5779XIkSPVpUsXZWVl6fvvv9dbb72lkydPysvLS5IUHx9v+rncakL3N954QxEREYqMjFS/fv0UFhamOnXqKC0tTZ988ol27txpSihJf/RC2bBhgx588EH1799fJ06cUHJystq1a1foPCRFMWzYMM2cObNUfi8BAABQsZAoAQAAQJXRrl077dmzRzNmzNDKlSt14cIFeXt7q3Pnzpo2bdpN9x0+fLiWLVuml156SRcvXpSvr68GDx6s6dOnF3i4vmjRItO8DteuXdPQoUP14osvmg3z8/DDD8vPz0+zZ8/Wc889p+zsbDVs2FC9evVSTEyMqV6nTp305ZdfaurUqVqyZImuXr2qpk2batCgQaXymtSsWVOfffaZEhIStHHjRq1atUre3t6666671KhRo5vuO3nyZLVq1UovvPCCZsyYIemPuSH69u1b4uGHwsLCtGXLFiUkJGjatGmqVq2aQkNDNWfOnCJP3G6Jj4+Pdu3apSeffFILFy7U1atX1bFjR7333nvq379/iWKOioqSo6OjkpKSlJGRoW7dumnRokVq0KBBmV7X8uXLVb9+fa1evVqbNm3SnXfeqc2bN5vm6LiZatWqadWqVYqPj9cjjzyi69eva8WKFWaxREVFadGiRbrrrrvMruXPWrZsqYULF2rSpEk6evSoAgICtG7dOrP5gKpXr64dO3Zo1qxZWr9+vV577TV5eHioVatWmjFjhjw9PYt1/d7e3tq1a5eWLl2qdevWacaMGbpy5Yq8vLwUFBSk1atXa/Dgwab6I0eOVFpampYuXaqPPvpI7dq10xtvvKH169dr+/btxYpB+mNuoSlTppj9/gIAAKBqcDDKY5ZAAAAAoApYuXKlYmJi9PXXXysoKMjW4QCl4ttvv1VgYKBee+01jRgxosB2f39/tW/fXu+//74NogMAAADKHnOUAAAAAIAde/nll1WzZk099NBDtg4FAAAAsAmG3gIAAAAAO/Tee+/p0KFDWrZsmWJjY00TvwMAAAD2hkQJAAAAANihf/7zn0pPT9c999xjmoMGAAAAsEfMUQIAAAAAAAAAAOwWc5QAAAAAAAAAAAC7RaIEAAAAAAAAAADYrSoxR0leXp7OnDmjWrVqycHBwdbhAAAAAAAAAAAAGzIMQ7/99pv8/Pzk6HjzPiNVIlFy5swZNW7c2NZhAAAAAAAAAACACuT06dNq1KjRTetUiURJrVq1JP1xwR4eHjaOBgAAAAAAAAAA2FJmZqYaN25syh/cTJVIlOQPt+Xh4UGiBAAAAAAAAAAASFKRputgMncAAAAAAAAAAGC3SJQAAAAAAAAAAAC7RaIEAAAAAAAAAADYrSoxRwkAAAAAAAAAoHLJzc3VtWvXbB0GKrFq1arJycmpxMchUQIAAAAAAAAAKDeGYSgtLU0XL160dSioAmrXri1fX98iTdpeGBIlAAAAAAAAAIByk58k8fb2VvXq1Uv0gBv2yzAMXblyRRkZGZKkBg0aFPtYJEoAAAAAAAAAAOUiNzfXlCSpV6+ercNBJefu7i5JysjIkLe3d7GH4WIydwAAAAAAAABAucifk6R69eo2jgRVRf69VJL5buhRAgCADfhP3my2fnJ2fxtFAgAAAABA+WO4LZSW0riX6FECAAAAAAAAAADsFokSAAAAAAAAAABgtxh6CwAAAAAAAABgczcOU12WrB0Ce+TIkVq1apUkydnZWY0aNdLAgQP19NNPy83NzVQvfxio1NRU3X777aby7Oxs+fn56ZdfftG2bdvUp08fSdKOHTs0Y8YM7d+/X1evXlXDhg3VvXt3vfzyy3JxcdH27dt1xx13WIzp7Nmz8vX1teo6YBk9SgAAAAAAAAAAuIWIiAidPXtW//nPf/TCCy9o6dKlSkhIKFCvcePGWrFihVnZxo0bVbNmTbOyQ4cOKSIiQkFBQdq5c6e+//57LVy4UC4uLsrNzTWre/ToUZ09e9Zs8fb2Lv2LvImcnJxSrVeRkCgBAAAAAAAAAOAWXF1d5evrq8aNGysyMlJhYWHaunVrgXrR0dFau3atfv/9d1PZ8uXLFR0dbVbv448/lq+vr+bOnav27durefPmioiI0Msvvyx3d3ezut7e3vL19TVbHB0tP97fvn27HBwctHnzZnXs2FFubm66/fbbdeDAAbN6n3/+uXr16iV3d3c1btxYjz32mLKyskzb/f39NXPmTEVFRcnDw0Njx461eL4+ffooNjZWEyZMkJeXl8LDw00xfPTRR+rcubPc3d115513KiMjQx9++KHatm0rDw8PPfzww7py5YrpWHl5eUpMTFRAQIDc3d3VqVMnvfXWW4X8REoPiRIAAAAAAAAAAKxw4MAB7dq1Sy4uLgW2denSRf7+/nr77bclSadOndLOnTs1YsQIs3q+vr46e/asdu7cWSYxTpo0SfPmzdPXX3+t+vXr67777tO1a9ckScePH1dERIQGDBig7777TuvWrdPnn3+u2NhYs2M8//zz6tSpk7755htNnTq10HOtWrVKLi4u+uKLL5ScnGwqnz59uhYtWqRdu3bp9OnTGjRokJKSkrRmzRpt3rxZH3/8sRYuXGiqn5iYqNdee03Jyck6ePCgJk6cqOHDh2vHjh2l/OqYY44SAAAAAAAAAABu4f3331fNmjV1/fp1ZWdny9HRUYsWLbJYd9SoUVq+fLmGDx+ulStX6p577lH9+vXN6gwcOFAfffSRQkND5evrq9tvv1133XWXqQfHnzVq1MhsvWnTpjp48OBN401ISNDdd98t6Y9ERqNGjbRx40YNGjRIiYmJGjZsmCZMmCBJatmypV588UWFhoZqyZIlpnlX7rzzTv3rX/+65WvTsmVLzZ0717R+9uxZSdIzzzyjHj16SJJGjx6t+Ph4HT9+XM2aNZMk/fWvf9W2bdv05JNPKjs7W7NmzdInn3yikJAQSVKzZs30+eefa+nSpQoNDb1lHMVFogQAAAAAAAAAgFu44447tGTJEmVlZemFF16Qs7OzBgwYYLHu8OHDNXnyZP3nP//RypUr9eKLLxao4+TkpBUrVuiZZ57Rp59+qq+++kqzZs3SnDlztHv3bjVo0MBU97PPPlOtWrVM69WqVbtlvPnJBkmqW7euWrdurcOHD0uSvv32W3333XdavXq1qY5hGMrLy9OJEyfUtm1bSVJQUNAtzyP90YvGko4dO5r+7+Pjo+rVq5uSJPllu3fvliQdO3ZMV65cMSV38uXk5Khz585FiqO4SJQAAAAAAAAAAHALNWrUUIsWLST9MedIp06d9Oqrr2r06NEF6tarV0/33nuvRo8eratXr6pfv3767bffLB63YcOGGjFihEaMGKGZM2eqVatWSk5O1owZM0x1AgICVLt27VK7lsuXL+vvf/+7HnvssQLbmjRpYvp/jRo1inS8wur9OaHj4OBQIMHj4OCgvLw8U0yStHnzZjVs2NCsnqura5HiKK5izVGyePFi+fv7y83NTcHBwaaMjyUHDx7UgAED5O/vLwcHByUlJd302LNnz5aDg4Opyw8AAAAAAAAAABWJo6OjnnrqKU2ZMsVs0vY/GzVqlLZv366oqCg5OTkV6bh16tRRgwYNzCZVL64vv/zS9P9ff/1VP/zwg6mnyG233aZDhw6pRYsWBRZL866Uh3bt2snV1VWnTp0qEFPjxo3L9NxW9yhZt26d4uLilJycrODgYCUlJSk8PFxHjx6Vt7d3gfpXrlxRs2bNNHDgQE2cOPGmx/7666+1dOlSs+44AAAAAAAAAABUNAMHDtSkSZO0ePFiPf744wW2R0RE6Ny5cwXmG8m3dOlS7d+/Xw8++KCaN2+uq1ev6rXXXtPBgwfNJjiXpIyMDF29etWsrF69ejcdguvpp59WvXr15OPjo//7v/+Tl5eXIiMjJUlPPvmkbr/9dsXGxupvf/ubatSooUOHDmnr1q2FzrtS1mrVqqXHH39cEydOVF5ennr27KlLly7piy++kIeHh6Kjo8vs3Fb3KJk/f77GjBmjmJgYtWvXTsnJyapevbqWL19usX7Xrl313HPPaciQITftHnP58mUNGzZML7/8surUqWNtWAAAAAAAAAAAlBtnZ2fFxsZq7ty5FnuAODg4yMvLq9AeGt26ddPly5f1yCOP6C9/+YtCQ0P15ZdfatOmTQUmLm/durUaNGhgtuzdu/em8c2ePVvjx49Xly5dlJaWpvfee88US8eOHbVjxw798MMP6tWrlzp37qxp06bJz8+vmK9G6Zg5c6amTp2qxMREtW3bVhEREdq8ebMCAgLK9LwOhmEYRa2ck5Oj6tWr66233jJlniQpOjpaFy9e1DvvvHPT/f39/TVhwgSLw2pFR0erbt26euGFF9SnTx8FBgYWOkxXdna2srOzTeuZmZlq3LixLl26VGh2DgCAisR/8maz9ZOz+9soEgAAAAAAys/Vq1d14sQJBQQEyM3NzdbhVEnbt2/XHXfcoV9//bVU5zWpqAq7pzIzM+Xp6VmkvIFVPUrOnz+v3Nxc+fj4mJX7+PgoLS3NmkOZWbt2rfbt26fExMQi1U9MTJSnp6dpKevxyQAAAAAAAAAAQNVUrMncS9Pp06c1fvx4rV69usgZxPj4eF26dMm0nD59uoyjBAAAAAAAAAAAVZFVk7l7eXnJyclJ6enpZuXp6eny9fUtVgB79+5VRkaGbrvtNlNZbm6udu7cqUWLFik7O1tOTk5m+7i6ut50vhMAAAAAAAAAAOxRnz59ZMWMG5CVPUpcXFzUpUsXpaSkmMry8vKUkpKikJCQYgVw11136fvvv9f+/ftNS1BQkIYNG6b9+/cXSJIAAAAAAAAAAACUFqt6lEhSXFycoqOjFRQUpG7duikpKUlZWVmKiYmRJEVFRalhw4am+UZycnJ06NAh0/9//vln7d+/XzVr1lSLFi1Uq1YttW/f3uwcNWrUUL169QqUAwAAAAAAAAAAlCarEyWDBw/WuXPnNG3aNKWlpSkwMFBbtmwxTfB+6tQpOTr+r6PKmTNn1LlzZ9P6888/r+eff16hoaHavn17ya8AAAAAAAAAAACgmKxOlEhSbGysYmNjLW67Mfnh7+9v9XhoJFAAAAAAAAAAAEB5sGqOEgAAAAAAAAAAgKqERAkAAAAAAAAAALBbJEoAAAAAAAAAAIDdKtYcJQAAAAAAAAAAlKr3xpffue5bYFX1kSNHatWqVfr73/+u5ORks23jxo3TSy+9pOjoaK1cudJsW2pqqnr27KmIiAht3rzZbNvJkycVEBBg8Xypqam6/fbbrYoRxUePEgAAAAAAAAAAbqFx48Zau3atfv/9d1PZ1atXtWbNGjVp0sTiPq+++qr++c9/aufOnTpz5ozFOp988onOnj1rtnTp0qVMrqEwOTk5pVqvsiFRAgAAAAAAAADALdx2221q3LixNmzYYCrbsGGDmjRpos6dOxeof/nyZa1bt07/+Mc/1L9//wK9TfLVq1dPvr6+Zku1atUs1j158qQcHBy0du1ade/eXW5ubmrfvr127NhhVu/AgQPq16+fatasKR8fH40YMULnz583be/Tp49iY2M1YcIEeXl5KTw83OL5Ro4cqcjISD377LPy8/NT69atTTH8+9//Vq9eveTu7q6uXbvqhx9+0Ndff62goCDVrFlT/fr107lz58yO98orr6ht27Zyc3NTmzZt9NJLL1k8b3kjUQIAAAAAAAAAQBGMGjVKK1asMK0vX75cMTExFuv++9//Vps2bdS6dWsNHz5cy5cvl2EYpRLHpEmT9K9//UvffPONQkJCdN999+nChQuSpIsXL+rOO+9U586dtWfPHm3ZskXp6ekaNGiQ2TFWrVolFxcXffHFFwWGE/uzlJQUHT16VFu3btX7779vKk9ISNCUKVO0b98+OTs76+GHH9YTTzyhBQsW6LPPPtOxY8c0bdo0U/3Vq1dr2rRpevbZZ3X48GHNmjVLU6dO1apVq0rlNSkJ5igBAAAAAAAAAKAIhg8frvj4eP3000+SpC+++EJr167V9u3bC9R99dVXNXz4cElSRESELl26pB07dqhPnz5m9bp37y5HR/M+DZcvX75pHLGxsRowYIAkacmSJdqyZYteffVVPfHEE1q0aJE6d+6sWbNmmeovX75cjRs31g8//KBWrVpJklq2bKm5c+fe8ppr1KihV155RS4uLpL+6NUiSY8//ripJ8r48eM1dOhQpaSkqEePHpKk0aNHm/WiSUhI0Lx58/TQQw9JkgICAnTo0CEtXbpU0dHRt4yjLJEoAQAAAAAAAACgCOrXr28aRsswDPXv319eXl4F6h09elS7d+/Wxo0bJUnOzs4aPHiwXn311QKJknXr1qlt27ZWxRESEmL6v7Ozs4KCgnT48GFJ0rfffqtt27apZs2aBfY7fvy4KVFS1HlQOnToYEqS/FnHjh1N//fx8THV/XNZRkaGJCkrK0vHjx/X6NGjNWbMGFOd69evy9PTs0hxlCUSJQAAAAAAAAAAFNGoUaMUGxsrSVq8eLHFOq+++qquX78uPz8/U5lhGHJ1ddWiRYvMkgONGzdWixYtSi2+y5cv67777tOcOXMKbGvQoIHp/zVq1CjS8Qqr9+d5VBwcHCyW5eXlmWKSpJdfflnBwcFmx3FycipSHGWJRAkAAAAAAAAAAEUUERGhnJwcOTg4WJwE/fr163rttdc0b9489e3b12xbZGSk3nzzTT3yyCMliuHLL79U7969Tefbu3evKXlz22236e2335a/v7+cnStGCsDHx0d+fn76z3/+o2HDhtk6nAIqxqsEAAAAAAAAAEAl4OTkZBrmylJviPfff1+//vqrRo8eXWBYqQEDBujVV181S5RcuHBBaWlpZvVq164tNze3QmNYvHixWrZsqbZt2+qFF17Qr7/+qlGjRkmSxo0bp5dffllDhw7VE088obp16+rYsWNau3atXnnlFZv14JgxY4Yee+wxeXp6KiIiQtnZ2dqzZ49+/fVXxcXF2SSmfI63rgIAAAAAAAAAAPJ5eHjIw8PD4rZXX31VYWFhFufeGDBggPbs2aPvvvvOVBYWFqYGDRqYLZs2bbrp+WfPnq3Zs2erU6dO+vzzz/Xuu++a5krx8/PTF198odzcXPXt21cdOnTQhAkTVLt27QKTxpenv/3tb3rllVe0YsUKdejQQaGhoVq5cqUCAgJsFlM+B8MwDFsHUVKZmZny9PTUpUuXCr05AQCoSPwnbzZbPzm7v40iAQAAAACg/Fy9elUnTpxQQEDATXtMwLKTJ08qICBA33zzjQIDA20dToVQ2D1lTd6AobfsAA/jAAAAAAAAAACwjKG3AAAAAAAAAACA3aJHCQAAAAAAAAAAlYC/v7+qwGwaFQ49SgAAAAAAAAAAgN0qVqJk8eLF8vf3l5ubm4KDg7V79+5C6x48eFADBgyQv7+/HBwclJSUVKBOYmKiunbtqlq1asnb21uRkZE6evRocUIDAAAAAAAAAAAoMqsTJevWrVNcXJwSEhK0b98+derUSeHh4crIyLBY/8qVK2rWrJlmz54tX19fi3V27NihcePG6csvv9TWrVt17do19e3bV1lZWdaGBwAAAAAAAACo4PLy8mwdAqqI0riXrJ6jZP78+RozZoxiYmIkScnJydq8ebOWL1+uyZMnF6jftWtXde3aVZIsbpekLVu2mK2vXLlS3t7e2rt3r3r37m1tiAAAAAAAAACACsjFxUWOjo46c+aM6tevLxcXFzk4ONg6LFRChmEoJydH586dk6Ojo1xcXIp9LKsSJTk5Odq7d6/i4+NNZY6OjgoLC1Nqamqxg7jRpUuXJEl169YttWMCAAAAAAAAAGzL0dFRAQEBOnv2rM6cOWPrcFAFVK9eXU2aNJGjY/GnZLcqUXL+/Hnl5ubKx8fHrNzHx0dHjhwpdhB/lpeXpwkTJqhHjx5q3769xTrZ2dnKzs42rWdmZpbKuQEAAAAAAAAAZcvFxUVNmjTR9evXlZuba+twUIk5OTnJ2dm5xL2SrB56q6yNGzdOBw4c0Oeff15oncTERM2YMaMcowIAAAAAAAAAlBYHBwdVq1ZN1apVs3UogHWTuXt5ecnJyUnp6elm5enp6YVO1G6N2NhYvf/++9q2bZsaNWpUaL34+HhdunTJtJw+fbrE5wYAAAAAAAAAAPbHqkSJi4uLunTpopSUFFNZXl6eUlJSFBISUuwgDMNQbGysNm7cqE8//VQBAQE3re/q6ioPDw+zBQAAAAAAAAAAwFpWD70VFxen6OhoBQUFqVu3bkpKSlJWVpZiYmIkSVFRUWrYsKESExMl/TEB/KFDh0z///nnn7V//37VrFlTLVq0kPTHcFtr1qzRO++8o1q1aiktLU2S5OnpKXd391K5UAAAAAAAAAAAgBtZnSgZPHiwzp07p2nTpiktLU2BgYHasmWLaYL3U6dOmc0uf+bMGXXu3Nm0/vzzz+v5559XaGiotm/fLklasmSJJKlPnz5m51qxYoVGjhxpbYgAAAAAAAAAAABFUqzJ3GNjYxUbG2txW37yI5+/v78Mw7jp8W61HQAAAAAAAAAAoCxYNUcJAAAAAAAAAABAVUKiBAAAAAAAAAAA2C0SJQAAAAAAAAAAwG6RKAEAAAAAAAAAAHaLRAkAAAAAAAAAALBbJEoAAAAAAAAAAIDdIlECAAAAAAAAAADsFokSAAAAAAAAAABgt0iUAAAAAAAAAAAAu0WiBAAAAAAAAAAA2C0SJQAAAAAAAAAAwG452zoAVCz+kzebrZ+c3d9GkQAAAAAAAAAAUPboUQIAAAAAAAAAAOwWiRIAAAAAAAAAAGC3SJQAAAAAAAAAAAC7RaIEAAAAAAAAAADYLRIlAAAAAAAAAADAbpEoAQAAAAAAAAAAdotECQAAAAAAAAAAsFvFSpQsXrxY/v7+cnNzU3BwsHbv3l1o3YMHD2rAgAHy9/eXg4ODkpKSSnxMAAAAAAAAAACA0mB1omTdunWKi4tTQkKC9u3bp06dOik8PFwZGRkW61+5ckXNmjXT7Nmz5evrWyrHBAAAAAAAAAAAKA1WJ0rmz5+vMWPGKCYmRu3atVNycrKqV6+u5cuXW6zftWtXPffccxoyZIhcXV1L5ZgAAAAAAAAAAAClwapESU5Ojvbu3auwsLD/HcDRUWFhYUpNTS1WAMU5ZnZ2tjIzM80WAAAAAAAAAAAAa1mVKDl//rxyc3Pl4+NjVu7j46O0tLRiBVCcYyYmJsrT09O0NG7cuFjnBgAAAAAAAAAA9q1Yk7nbWnx8vC5dumRaTp8+beuQAAAAAAAAAABAJeRsTWUvLy85OTkpPT3drDw9Pb3QidrL4piurq6FzncCAAAAAAAAAABQVFb1KHFxcVGXLl2UkpJiKsvLy1NKSopCQkKKFUBZHBMAAAAAAAAAAKAorOpRIklxcXGKjo5WUFCQunXrpqSkJGVlZSkmJkaSFBUVpYYNGyoxMVHSH5O1Hzp0yPT/n3/+Wfv371fNmjXVokWLIh0TAIAb+U/ebLZ+cnZ/G0XyPzfGJFWMuAAAAAAAAFA4qxMlgwcP1rlz5zRt2jSlpaUpMDBQW7ZsMU3GfurUKTk6/q+jypkzZ9S5c2fT+vPPP6/nn39eoaGh2r59e5GOCQAAAAAAAAAAUBasTpRIUmxsrGJjYy1uy09+5PP395dhGCU6JgAAAAAAAAAAQFkoVqIEAAB7UhGH+QIAAAAAAEDpsGoydwAAAAAAAAAAgKqERAkAAAAAAAAAALBbDL0FAMD/d+MQWxLDbAEAAAAAAFR19CgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRKAAAAAAAAAACA3SJRAgAAAAAAAAAA7BaJEgAAAAAAAAAAYLdIlAAAAAAAAAAAALtFogQAAAAAAAAAANgtEiUAAAAAAAAAAMBukSgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRKAAAAAAAAAACA3SJRAgAAAAAAAAAA7BaJEgAAAAAAAAAAYLdIlAAAAAAAAAAAALtVrETJ4sWL5e/vLzc3NwUHB2v37t03rb9+/Xq1adNGbm5u6tChgz744AOz7ZcvX1ZsbKwaNWokd3d3tWvXTsnJycUJDQAAAAAAAAAAoMisTpSsW7dOcXFxSkhI0L59+9SpUyeFh4crIyPDYv1du3Zp6NChGj16tL755htFRkYqMjJSBw4cMNWJi4vTli1b9MYbb+jw4cOaMGGCYmNj9e677xb/ygAAAAAAAAAAAG7B6kTJ/PnzNWbMGMXExJh6flSvXl3Lly+3WH/BggWKiIjQpEmT1LZtW82cOVO33XabFi1aZKqza9cuRUdHq0+fPvL399fYsWPVqVOnW/ZUAQAAAAAAAAAAKAmrEiU5OTnau3evwsLC/ncAR0eFhYUpNTXV4j6pqalm9SUpPDzcrH737t317rvv6ueff5ZhGNq2bZt++OEH9e3b1+Ixs7OzlZmZabYAAAAAAAAAAABYy6pEyfnz55WbmysfHx+zch8fH6WlpVncJy0t7Zb1Fy5cqHbt2qlRo0ZycXFRRESEFi9erN69e1s8ZmJiojw9PU1L48aNrbkMAAAAAAAAAAAASZKzrQOQ/kiUfPnll3r33XfVtGlT7dy5U+PGjZOfn1+B3iiSFB8fr7i4ONN6ZmYmyRIAQLnyn7zZbP3k7P42igQAAAAAAAAlYVWixMvLS05OTkpPTzcrT09Pl6+vr8V9fH19b1r/999/11NPPaWNGzeqf/8/HjJ17NhR+/fv1/PPP28xUeLq6ipXV1drQgcAADBDsgsAAAAAAEhWDr3l4uKiLl26KCUlxVSWl5enlJQUhYSEWNwnJCTErL4kbd261VT/2rVrunbtmhwdzUNxcnJSXl6eNeEBAFAh+U/ebLYAAAAAAACg4rB66K24uDhFR0crKChI3bp1U1JSkrKyshQTEyNJioqKUsOGDZWYmChJGj9+vEJDQzVv3jz1799fa9eu1Z49e7Rs2TJJkoeHh0JDQzVp0iS5u7uradOm2rFjh1577TXNnz+/FC8VAAAAAAAAAADAnNWJksGDB+vcuXOaNm2a0tLSFBgYqC1btpgmbD916pRZ75Du3btrzZo1mjJlip566im1bNlSmzZtUvv27U111q5dq/j4eA0bNky//PKLmjZtqmeffVaPPPJIKVwiAAAAAAAAAACAZcWazD02NlaxsbEWt23fvr1A2cCBAzVw4MBCj+fr66sVK1YUJxQAAAAAAAAAAIBis2qOEgAAAAAAAAAAgKqERAkAAAAAAAAAALBbJEoAAAAAAAAAAIDdIlECAAAAAAAAAADsVrEmcwcAAPbDf/Jms/WTs/vbKBIAAAAAAIDSR48SAAAAAAAAAABgt0iUAAAAAAAAAAAAu8XQWwAA2MAs51duKGE4KwAAAAAAAFsgUQK7ZWnMfcbhBwAAAAAAAAD7QqIEVd6NyQ+JBAgAAAAAAAAA4A8kSgAAsEMkkQEAAAAAAP7AZO4AAAAAAAAAAMBukSgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRKAAAAAAAAAACA3SJRAgAAAAAAAAAA7JazrQOAffKfvLlA2cnZ/W0QCQAAAAAAAADAntGjBAAAAAAAAAAA2K1iJUoWL14sf39/ubm5KTg4WLt3775p/fXr16tNmzZyc3NThw4d9MEHHxSoc/jwYd1///3y9PRUjRo11LVrV506dao44QEAAAAAAAAAABSJ1YmSdevWKS4uTgkJCdq3b586deqk8PBwZWRkWKy/a9cuDR06VKNHj9Y333yjyMhIRUZG6sCBA6Y6x48fV8+ePdWmTRtt375d3333naZOnSo3N7fiXxkAAAAAAAAAAMAtWJ0omT9/vsaMGaOYmBi1a9dOycnJql69upYvX26x/oIFCxQREaFJkyapbdu2mjlzpm677TYtWrTIVOf//u//dM8992ju3Lnq3Lmzmjdvrvvvv1/e3t7FvzIAAAAAAAAAAIBbsCpRkpOTo7179yosLOx/B3B0VFhYmFJTUy3uk5qaalZfksLDw0318/LytHnzZrVq1Urh4eHy9vZWcHCwNm3aZOWloCrwn7zZbAEAAAAAAAAAoCw5W1P5/Pnzys3NlY+Pj1m5j4+Pjhw5YnGftLQ0i/XT0tIkSRkZGbp8+bJmz56tZ555RnPmzNGWLVv00EMPadu2bQoNDS1wzOzsbGVnZ5vWMzMzrbkMAABQiBuT1Cdn97dRJEDp4b4GAAAAANyMVYmSspCXlydJeuCBBzRx4kRJUmBgoHbt2qXk5GSLiZLExETNmDGjXONE8fFwAgBsi3YYAAAAAACgcFYNveXl5SUnJyelp6eblaenp8vX19fiPr6+vjet7+XlJWdnZ7Vr186sTtu2bXXq1CmLx4yPj9elS5dMy+nTp625DAAAAAAAAAAAAElW9ihxcXFRly5dlJKSosjISEl/9AhJSUlRbGysxX1CQkKUkpKiCRMmmMq2bt2qkJAQ0zG7du2qo0ePmu33ww8/qGnTphaP6erqKldXV2tCBwAAQBViaS6zk7P704MKAAAAAGA1q4feiouLU3R0tIKCgtStWzclJSUpKytLMTExkqSoqCg1bNhQiYmJkqTx48crNDRU8+bNU//+/bV27Vrt2bNHy5YtMx1z0qRJGjx4sHr37q077rhDW7Zs0Xvvvaft27eXzlUCAAAAAAAAAABYYHWiZPDgwTp37pymTZumtLQ0BQYGasuWLaYJ20+dOiVHx/+N6NW9e3etWbNGU6ZM0VNPPaWWLVtq06ZNat++vanOgw8+qOTkZCUmJuqxxx5T69at9fbbb6tnz56lcImY5fzKDSV8sxIAqiq+TQ8AAAAAAGCdYk3mHhsbW+hQW5Z6gQwcOFADBw686TFHjRqlUaNGFSccAAAAAAAAAACAYrFqMncAAAAAAAAAAICqhEQJAAAAAAAAAACwWyRKAAAAAAAAAACA3SJRAgAAAAAAAAAA7FaxJnMHypP/5M1m6ydn979pOQAAAAAAAAAARUWiBFUKyROgcrP17/As51cslPa3UG45rsL2BwAAAAAAQMXF0FsAAAAAAAAAAMBukSgBAAAAAAAAAAB2i6G37NSNw9tIDFMFAAAAAAAAALA/JEoAAKXG0hwjJGYBAAAAAABQkZEoAWDCA20AAAAAAAAA9oZECWCnLH3zHwAAVD18EQIAAAAAbo5ECYBiIdECAED5KCzRwd9iAAAAACgdJEoAAJXSLOdXbijhASEAkDwBAAAAAOuRKAEAAADKUGHJC0vlJDoAAAAAoPw52joAAAAAAAAAAAAAWyFRAgAAAAAAAAAA7BZDb8FuWZrfgDkPAAAAAAAAAMC+kChBlVcw+SGRAAEAAAAAAAAASMUcemvx4sXy9/eXm5ubgoODtXv37pvWX79+vdq0aSM3Nzd16NBBH3zwQaF1H3nkETk4OCgpKak4oaGEZjm/YrYAAAAAAAAAAFCVWZ0oWbduneLi4pSQkKB9+/apU6dOCg8PV0ZGhsX6u3bt0tChQzV69Gh98803ioyMVGRkpA4cOFCg7saNG/Xll1/Kz8/P+isBAAAAAAAAAACwktWJkvnz52vMmDGKiYlRu3btlJycrOrVq2v58uUW6y9YsEARERGaNGmS2rZtq5kzZ+q2227TokWLzOr9/PPP+uc//6nVq1erWrVqxbsaAAAAAAAAAAAAK1iVKMnJydHevXsVFhb2vwM4OiosLEypqakW90lNTTWrL0nh4eFm9fPy8jRixAhNmjRJf/nLX24ZR3Z2tjIzM80WAAAAAAAAAAAAa1k1mfv58+eVm5srHx8fs3IfHx8dOXLE4j5paWkW66elpZnW58yZI2dnZz322GNFiiMxMVEzZsywJnSUE//Jm83WT85m0nQAVVPBeZxo7wrD3wYAAAAAAFCRFWsy99K0d+9eLViwQCtXrpSDg0OR9omPj9elS5dMy+nTp8s4SgAAAAAAAAAAUBVZlSjx8vKSk5OT0tPTzcrT09Pl6+trcR9fX9+b1v/ss8+UkZGhJk2ayNnZWc7Ozvrpp5/0r3/9S/7+/haP6erqKg8PD7MFAAAAAAAAAADAWlYNveXi4qIuXbooJSVFkZGRkv6YXyQlJUWxsbEW9wkJCVFKSoomTJhgKtu6datCQkIkSSNGjLA4h8mIESMUExNjTXgAAFRIVXGYrhuH05IYUgsAAAAAAFROViVKJCkuLk7R0dEKCgpSt27dlJSUpKysLFNSIyoqSg0bNlRiYqIkafz48QoNDdW8efPUv39/rV27Vnv27NGyZcskSfXq1VO9evXMzlGtWjX5+vqqdevWJb0+AEAVwBwXpa9g8kaqCgkcAAAAAAAAa1mdKBk8eLDOnTunadOmKS0tTYGBgdqyZYtpwvZTp07J0fF/I3p1795da9as0ZQpU/TUU0+pZcuW2rRpk9q3b196V4EyxQNKALBv1vSI4W8Gyos1yb6q2KsLAAAAAFB6rE6USFJsbGyhQ21t3769QNnAgQM1cODAIh//5MmTxQkLAAAAdo6kCAAAAADAWsVKlACMTQ+gpOh5AAAAAAAAgIrA8dZVAAAAAAAAAAAAqiYSJQAAAAAAAAAAwG4x9BYA2CmGvgIAAABQXHyeAABUJSRKAJQa5q4BKiZrJrdmImwAAAAAAGBvSJQAAFCFkOgAAAAAAACwDokSAAAAAAAAVFgM8wUAKGskSgAAVQbDvwEAyoulh3b8HQJQFdG2AQDsAYkSALfEt3dQ2XEPAwAqGh48AgAAABUHiRIAAADgJqxJtpKYBQAAAIDKh0QJAMAu8TATAAAAAAAAEokSuzXL+RULpTwkLE88pAWAyo12HAAAAACAqoFECWCnCibL+luVQLO0PwAAAAAAAABUNiRKYBP0aAEAy+ilUPqsmTDZ0uvPhMsAAAAAAFRtJEpQ5qzpeVDZeynwgBNAWaBtAQAAAAAAKDskSgBUeDwkBgqil0Plwc8KAADYOz7TAQAqOhIlAMpcUYay4Y1yxcCwQ7Anlb0XI2AJ9zUAAAAAWI9ECQAAQCkhCYyywNxuAAAAAFC2HIuz0+LFi+Xv7y83NzcFBwdr9+7dN62/fv16tWnTRm5uburQoYM++OAD07Zr167pySefVIcOHVSjRg35+fkpKipKZ86cKU5oAAAAQKUwy/kVswUAAAAAYBtW9yhZt26d4uLilJycrODgYCUlJSk8PFxHjx6Vt7d3gfq7du3S0KFDlZiYqHvvvVdr1qxRZGSk9u3bp/bt2+vKlSvat2+fpk6dqk6dOunXX3/V+PHjdf/992vPnj2lcpGo3AobQsJSeVkMN1HYsENF/dYwwxYBAICisua9TFHr0iPF9uhtBgClj7YVAFCarE6UzJ8/X2PGjFFMTIwkKTk5WZs3b9by5cs1efLkAvUXLFigiIgITZo0SZI0c+ZMbd26VYsWLVJycrI8PT21detWs30WLVqkbt266dSpU2rSpElxrgsAUMaK+sHEmgd0jK0PoCqibYM1ePAHAAAAlD+rEiU5OTnau3ev4uPjTWWOjo4KCwtTamqqxX1SU1MVFxdnVhYeHq5NmzYVep5Lly7JwcFBtWvXtiY8AICN8TAQAAAAAAAAlY1ViZLz588rNzdXPj4+ZuU+Pj46cuSIxX3S0tIs1k9LS7NY/+rVq3ryySc1dOhQeXh4WKyTnZ2t7Oxs03pmZqY1lwEAACoAvjUNW2JoTAAAAABAPquH3ipL165d06BBg2QYhpYsWVJovcTERM2YMaMcIwMAALZizQNtki8oLyRaAAAAAKDqsCpR4uXlJScnJ6Wnp5uVp6eny9fX1+I+vr6+RaqfnyT56aef9Omnnxbam0SS4uPjzYbzyszMVOPGja25FABlgMliAZSUNYkOkiIoC9xXAAAAAGB/rEqUuLi4qEuXLkpJSVFkZKQkKS8vTykpKYqNjbW4T0hIiFJSUjRhwgRT2datWxUSEmJaz0+S/Pjjj9q2bZvq1at30zhcXV3l6upqTegASoB5JwAAAICqhcQwAADA/1g99FZcXJyio6MVFBSkbt26KSkpSVlZWYqJiZEkRUVFqWHDhkpMTJQkjR8/XqGhoZo3b5769++vtWvXas+ePVq2bJmkP5Ikf/3rX7Vv3z69//77ys3NNc1fUrduXbm4uJTWtQIAAAAAgFJAL1AAAFCVWJ0oGTx4sM6dO6dp06YpLS1NgYGB2rJli2nC9lOnTsnR0dFUv3v37lqzZo2mTJmip556Si1bttSmTZvUvn17SdLPP/+sd999V5IUGBhodq5t27apT58+xbw0AAAAAIA17OmBtqVr5eE/YFvMAQYAsJViTeYeGxtb6FBb27dvL1A2cOBADRw40GJ9f39/GYZRnDBQTiwNu1TYXBQM0QSgqGgvKjdr5iTiZw0AAAAAACqyYiVKAACVX2V6eF2ZYrV3/KwAwLaK2suBb20DsDV6ZQEAKhISJUApKukDwsLeKPKBFwAAALbCw8yi47UCAAConEiUAAAAAICVrBmetqQq08P3ks77URbnL+1jltZxUTL8XCqmytReAQDwZyRKABtheBoAAAD7VVZJlcqOh6wASoIEGgCguEiUAABQgRTtG8pl961lAEDVY+/JBx6cFl15vlaFncve71cAAGAbJEoAVEp84IUlhSUP6MGForImKcV9BcCelcZ7MebhqzxIXqCkeN8EAKjoSJQAqFD4EIbywoc1+2Hr3je2Pj9Kzpr2ojK1LbaeSwJA1VQe88TQNpUdS691RfjSSFF7XQMAUFwkSoBbKOmbQh6QAYD94AM7qiK+zY+KiofnAAAAKC0kSgCUuZJ++4cHjwCA0sYXIQCgZHg/D6CkSHgDqEhIlAAAAABAGeIhMSoi7ksAAID/IVECAAAAoEzxjdGi4+E1bKkizEVhayWdv4n2rmTosYmS4ncQQHGRKAEqKd6sAwCAqob5UIqO1wqVHUkZlAUSLbCEv5mwhPsCNyJRAlQghX0o4MOCfSPRhaqK+YsAoOIpadtq67a9pOfi71DJlcXrUrSfVemcCyXD7xAqk5L2IIP94L6wDyRKgCqEDwsVU1n1/ilqXWu+JcGHUFRE1tyDlekDd1E+mBVWbu0bc97YA/ajqO1gRfj7Xl6xVoRrBcqLNe8vgJIi0QCgKiFRAqBSKqsPvOX1pq6sPqyU55vSyvRAGkDR8CAF1mAc//Jj67+5FfWLFOX1ulTVhD0qj/L8+8w9jMqE9xKwF3xOKx8kSgBUKCV9Y27rN0q2Pj8A+1HSb4zSXgH2gweflUdJH4SUVc9ElExF/bnY+vyApb9P9IqCrdE22i8SJQCqPB4mAgBQUFHnZ6gIPQeAyq4shlDkPWrZsGbuGks/g/JMTHIPFF1Rf4d4IG9ZabdhxTlGUdn6ywHcQygp2nbbIVECVFJMkmdbvPkBUFLWPJCmHUdlV5nmzQAAAFWLNe+xSXbCGrZOwnIPlS4SJQBQxkr6MLSwN2p8ExhAUfGQGqh6+H0FSoYvPgElZ+tEQ2VKavBA27aK1gNQYg4y+1asRMnixYv13HPPKS0tTZ06ddLChQvVrVu3QuuvX79eU6dO1cmTJ9WyZUvNmTNH99xzj2m7YRhKSEjQyy+/rIsXL6pHjx5asmSJWrZsWZzwAKDYSvrHjz+eAMpLSROjtFcoqZI+HOEeBEofCbSKOUyZNV+SKouHefRYrVyKer+WdDjpijp3jiUVtW2riK8VgOKzOlGybt06xcXFKTk5WcHBwUpKSlJ4eLiOHj0qb2/vAvV37dqloUOHKjExUffee6/WrFmjyMhI7du3T+3bt5ckzZ07Vy+++KJWrVqlgIAATZ06VeHh4Tp06JDc3NxKfpUA7EZZ9LKglwYAAABKoqQ9+0hMVky2fl1tff7KpLL3xrfmgXxZPLwv/S8UFn6Myn5f29O1VlW27qlUmdqmqsbqRMn8+fM1ZswYxcTESJKSk5O1efNmLV++XJMnTy5Qf8GCBYqIiNCkSZMkSTNnztTWrVu1aNEiJScnyzAMJSUlacqUKXrggQckSa+99pp8fHy0adMmDRkypCTXBwAAAABAhcM3kctGZX8gDhQVX/4rX/Y++kR5Dj1W0p6BRU0+lAZb/82p7PdVRWNVoiQnJ0d79+5VfHy8qczR0VFhYWFKTU21uE9qaqri4uLMysLDw7Vp0yZJ0okTJ5SWlqawsDDTdk9PTwUHBys1NdVioiQ7O1vZ2dmm9UuXLkmSMjMzrbkcu3El+5rZemZmZoGywsqLWlbe+xf1uipCrFwr18prxbVyrfZ9rSXZv6LEWhFV1NeK34GyudaKqKr+vlem+6Ky7C9ZvtYpuUtuKOtl81j5udr+WrkvKua1lidL94A190VR6t7sWou6v1T5f64VsR2vqCxda/uEjwrUOzAjvED5gRnhFvf/98yHC+w/aOqaIv8OFHb+kv4OlGfbVhaxwlz+a2IYxq0rG1b4+eefDUnGrl27zMonTZpkdOvWzeI+1apVM9asWWNWtnjxYsPb29swDMP44osvDEnGmTNnzOoMHDjQGDRokMVjJiQkGJJYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFgKXU6fPn3L3EexJnO3tfj4eLNeKnl5efrll19Ur149OTg42DCyiiszM1ONGzfW6dOn5eHhYetwAFRgtBcAior2AkBR0V4AKCraCwDWoM3AzRiGod9++01+fn63rGtVosTLy0tOTk5KT083K09PT5evr6/FfXx9fW9aP//f9PR0NWjQwKxOYGCgxWO6urrK1dXVrKx27drWXIrd8vDwoNEAUCS0FwCKivYCQFHRXgAoKtoLANagzUBhPD09i1TP0ZqDuri4qEuXLkpJSTGV5eXlKSUlRSEhIRb3CQkJMasvSVu3bjXVDwgIkK+vr1mdzMxMffXVV4UeEwAAAAAAAAAAoDRYPfRWXFycoqOjFRQUpG7duikpKUlZWVmKiYmRJEVFRalhw4ZKTEyUJI0fP16hoaGaN2+e+vfvr7Vr12rPnj1atmyZJMnBwUETJkzQM888o5YtWyogIEBTp06Vn5+fIiMjS+9KAQAAAAAAAAAAbmB1omTw4ME6d+6cpk2bprS0NAUGBmrLli3y8fGRJJ06dUqOjv/rqNK9e3etWbNGU6ZM0VNPPaWWLVtq06ZNat++vanOE088oaysLI0dO1YXL15Uz549tWXLFrm5uZXCJUL6Y7iyhISEAkOWAcCNaC8AFBXtBYCior0AUFS0FwCsQZuB0uJgGIZh6yAAAAAAAAAAAABswao5SgAAAAAAAAAAAKoSEiUAAAAAAAAAAMBukSgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRK7MTixYvl7+8vNzc3BQcHa/fu3bYOCYANTZ8+XQ4ODmZLmzZtTNuvXr2qcePGqV69eqpZs6YGDBig9PR0G0YMoDzt3LlT9913n/z8/OTg4KBNmzaZbTcMQ9OmTVODBg3k7u6usLAw/fjjj2Z1fvnlFw0bNkweHh6qXbu2Ro8ercuXL5fjVQAoD7dqL0aOHFngPUdERIRZHdoLoOpLTExU165dVatWLXl7eysyMlJHjx41q1OUzyCnTp1S//79Vb16dXl7e2vSpEm6fv16eV4KgDJWlPaiT58+Bd5fPPLII2Z1aC9gLRIldmDdunWKi4tTQkKC9u3bp06dOik8PFwZGRm2Dg2ADf3lL3/R2bNnTcvnn39u2jZx4kS99957Wr9+vXbs2KEzZ87ooYcesmG0AMpTVlaWOnXqpMWLF1vcPnfuXL344otKTk7WV199pRo1aig8PFxXr1411Rk2bJgOHjyorVu36v3339fOnTs1duzY8roEAOXkVu2FJEVERJi953jzzTfNttNeAFXfjh07NG7cOH355ZfaunWrrl27pr59+yorK8tU51afQXJzc9W/f3/l5ORo165dWrVqlVauXKlp06bZ4pIAlJGitBeSNGbMGLP3F3PnzjVto71AsRio8rp162aMGzfOtJ6bm2v4+fkZiYmJNowKgC0lJCQYnTp1srjt4sWLRrVq1Yz169ebyg4fPmxIMlJTU8spQgAVhSRj48aNpvW8vDzD19fXeO6550xlFy9eNFxdXY0333zTMAzDOHTokCHJ+Prrr011PvzwQ8PBwcH4+eefyy12AOXrxvbCMAwjOjraeOCBBwrdh/YCsE8ZGRmGJGPHjh2GYRTtM8gHH3xgODo6GmlpaaY6S5YsMTw8PIzs7OzyvQAA5ebG9sIwDCM0NNQYP358ofvQXqA46FFSxeXk5Gjv3r0KCwszlTk6OiosLEypqak2jAyArf3444/y8/NTs2bNNGzYMJ06dUqStHfvXl27ds2s3WjTpo2aNGlCuwFAJ06cUFpamlkb4enpqeDgYFMbkZqaqtq1aysoKMhUJywsTI6Ojvrqq6/KPWYAtrV9+3Z5e3urdevW+sc//qELFy6YttFeAPbp0qVLkqS6detKKtpnkNTUVHXo0EE+Pj6mOuHh4crMzNTBgwfLMXoA5enG9iLf6tWr5eXlpfbt2ys+Pl5XrlwxbaO9QHE42zoAlK3z588rNzfXrGGQJB8fHx05csRGUQGwteDgYK1cuVKtW7fW2bNnNWPGDPXq1UsHDhxQWlqaXFxcVLt2bbN9fHx8lJaWZpuAAVQY+e2ApfcW+dvS0tLk7e1ttt3Z2Vl169alHQHsTEREhB566CEFBATo+PHjeuqpp9SvXz+lpqbKycmJ9gKwQ3l5eZowYYJ69Oih9u3bS1KRPoOkpaVZfP+Rvw1A1WOpvZCkhx9+WE2bNpWfn5++++47Pfnkkzp69Kg2bNggifYCxUOiBADsUL9+/Uz/79ixo4KDg9W0aVP9+9//lru7uw0jAwAAVcmQIUNM/+/QoYM6duyo5s2ba/v27brrrrtsGBkAWxk3bpwOHDhgNkciAFhSWHvx57nMOnTooAYNGuiuu+7S8ePH1bx58/IOE1UEQ29VcV5eXnJyclJ6erpZeXp6unx9fW0UFYCKpnbt2mrVqpWOHTsmX19f5eTk6OLFi2Z1aDcASDK1Azd7b+Hr66uMjAyz7devX9cvv/xCOwLYuWbNmsnLy0vHjh2TRHsB2JvY2Fi9//772rZtmxo1amQqL8pnEF9fX4vvP/K3AahaCmsvLAkODpYks/cXtBewFomSKs7FxUVdunRRSkqKqSwvL08pKSkKCQmxYWQAKpLLly/r+PHjatCggbp06aJq1aqZtRtHjx7VqVOnaDcAKCAgQL6+vmZtRGZmpr766itTGxESEqKLFy9q7969pjqffvqp8vLyTB9iANin//73v7pw4YIaNGggifYCsBeGYSg2NlYbN27Up59+qoCAALPtRfkMEhISou+//94subp161Z5eHioXbt25XMhAMrcrdoLS/bv3y9JZu8vaC9gLYbesgNxcXGKjo5WUFCQunXrpqSkJGVlZSkmJsbWoQGwkccff1z33XefmjZtqjNnzighIUFOTk4aOnSoPD09NXr0aMXFxalu3bry8PDQP//5T4WEhOj222+3degAysHly5dN38aS/pjAff/+/apbt66aNGmiCRMm6JlnnlHLli0VEBCgqVOnys/PT5GRkZKktm3bKiIiQmPGjFFycrKuXbum2NhYDRkyRH5+fja6KgBl4WbtRd26dTVjxgwNGDBAvr6+On78uJ544gm1aNFC4eHhkmgvAHsxbtw4rVmzRu+8845q1aplmiPA09NT7u7uRfoM0rdvX7Vr104jRozQ3LlzlZaWpilTpmjcuHFydXW15eUBKEW3ai+OHz+uNWvW6J577lG9evX03XffaeLEierdu7c6duwoifYCxWTALixcuNBo0qSJ4eLiYnTr1s348ssvbR0SABsaPHiw0aBBA8PFxcVo2LChMXjwYOPYsWOm7b///rvx6KOPGnXq1DGqV69uPPjgg8bZs2dtGDGA8rRt2zZDUoElOjraMAzDyMvLM6ZOnWr4+PgYrq6uxl133WUcPXrU7BgXLlwwhg4datSsWdPw8PAwYmJijN9++80GVwOgLN2svbhy5YrRt29fo379+ka1atWMpk2bGmPGjDHS0tLMjkF7AVR9ltoJScaKFStMdYryGeTkyZNGv379DHd3d8PLy8v417/+ZVy7dq2crwZAWbpVe3Hq1Cmjd+/eRt26dQ1XV1ejRYsWxqRJk4xLly6ZHYf2AtZyMAzDKM/EDAAAAAAAAAAAQEXBHCUAAAAAAAAAAMBukSgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRKAAAAAAAAAACA3SJRAgAAAAAAAAAA7BaJEgAAAAAAAAAAYLdIlAAAAAAAAAAAALtFogQAAAAAAAAAANgtEiUAAAAAAAAAAMBukSgBAAAAAAAAAAB2i0QJAAAAAAAAAACwWyRKAAAAAAAAAACA3fp/xkgn6O1NibwAAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "for bt, err in ana_result[\"hopping\"].items():\n",
+ " print(\"rmse err for bond {bt}: {rmserr} \\t mae err for bond {bt}: {maerr}\".format(bt=bt, rmserr=err[\"rmse\"], maerr=err[\"mae\"]))\n",
+ "\n",
+ "for bt, err in ana_result[\"onsite\"].items():\n",
+ " print(\"rmse err for atom {bt}: {rmserr} \\t mae err for bond {bt}: {maerr}\".format(bt=bt, rmserr=err[\"rmse\"], maerr=err[\"mae\"]))\n",
+ "\n",
+ "for bt, err in ana_result[\"hopping\"].items():\n",
+ " x = list(range(len(err[\"rmse_per_block_element\"])))\n",
+ " rmserr = err[\"rmse_per_block_element\"]\n",
+ " maerr = err[\"mae_per_block_element\"]\n",
+ " # l1amp = err[\"l1amp\"]\n",
+ " # l2amp = err[\"l2amp\"]\n",
+ "\n",
+ " plt.figure(figsize=(20,3))\n",
+ " plt.bar(x, rmserr.cpu().detach(), label=\"RMSE per rme\")\n",
+ " plt.bar(x, maerr.cpu().detach(), alpha=0.6, label=\"MAE per rme\")\n",
+ " plt.legend()\n",
+ " # plt.yscale(\"log\")\n",
+ " # plt.ylim([1e-5, 5e-2])\n",
+ " plt.title(\"rme specific error of bond type: {bt}\".format(bt=bt))\n",
+ " plt.show()\n",
+ "\n",
+ " # plt.figure(figsize=(20,3))\n",
+ " # plt.bar(x, l2amp.cpu().detach(), label=\"l2 amp per rme\")\n",
+ " # plt.bar(x, l1amp.cpu().detach(), alpha=0.6, label=\"l1 amp per rme\")\n",
+ " # plt.legend()\n",
+ " # # plt.yscale(\"log\")\n",
+ " # # plt.ylim([1e-5, 5e-2])\n",
+ " # plt.title(\"rme specific amp of bond type: {bt}\".format(bt=bt))\n",
+ " # plt.show()\n",
+ "\n",
+ "for at, err in ana_result[\"onsite\"].items():\n",
+ " x = list(range(len(err[\"rmse_per_block_element\"])))\n",
+ " rmserr = err[\"rmse_per_block_element\"]\n",
+ " maerr = err[\"mae_per_block_element\"]\n",
+ "\n",
+ " plt.figure(figsize=(20,3))\n",
+ " plt.bar(x, rmserr.cpu().detach(), label=\"RMSE per rme\")\n",
+ " plt.bar(x, maerr.cpu().detach(), alpha=0.6, label=\"MAE per rme\")\n",
+ " plt.legend()\n",
+ " # plt.yscale(\"log\")\n",
+ " # plt.ylim([1e-5, 5e-2])\n",
+ " plt.title(\"rme specific error of atom type: {at}\".format(at=at))\n",
+ " plt.show()\n",
+ "\n",
+ " # l1amp = err[\"l1amp\"]\n",
+ " # l2amp = err[\"l2amp\"]\n",
+ "\n",
+ " # plt.figure(figsize=(20,3))\n",
+ " # plt.bar(x, l2amp.cpu().detach(), label=\"l2 amp per rme\")\n",
+ " # plt.bar(x, l1amp.cpu().detach(), alpha=0.6, label=\"l1 amp per rme\")\n",
+ " # plt.legend()\n",
+ " # # plt.yscale(\"log\")\n",
+ " # # plt.ylim([1e-5, 5e-2])\n",
+ " # plt.title(\"rme specific amp of atom type: {at}\".format(at=at))\n",
+ " # plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor(178, device='cuda:0')"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ana_result[\"onsite\"][\"Ga\"][\"rmse_per_block_element\"].argmax()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 87,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dptb.nn.nnsk import NNSK\n",
+ "import json\n",
+ "from dptb.utils.tools import j_loader\n",
+ "\n",
+ "from dptb.nn.hr2hk import HR2HK\n",
+ "from dptb.nn.energy import Eigenvalues\n",
+ "from dptb.data import AtomicData, AtomicDataDict, ABACUSDataset\n",
+ "from dptb.data.transforms import OrbitalMapper\n",
+ "from ase.io import read, write\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "dN = 141\n",
+ "atoms = train_dataset[dN].to_ase()\n",
+ "\n",
+ "import numpy as np\n",
+ "from dptb.utils.make_kpoints import abacus_kpath\n",
+ "\n",
+ "kpts = np.array([[0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.5000000000, 0.0000000000, 0.0000000000, 1], \n",
+ " [0.0000000000, 0.5000000000, 0.0000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.5000000000, 1], \n",
+ " [-0.500000000, -0.500000000, 0.5000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.5000000000, -0.500000000, 0.5000000000, 1],\n",
+ " [-0.500000000, 0.0000000000, 0.5000000000, 30],\n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30],\n",
+ " [0.5000000000, -0.500000000, 0.0000000000, 1 ],\n",
+ " ])\n",
+ "kpoints, xlist, hsp = abacus_kpath(atoms, kpts)\n",
+ "\n",
+ "import torch\n",
+ "\n",
+ "data = train_dataset[dN].to_AtomicDataDict(train_dataset[dN].to(common_options[\"device\"]))\n",
+ "data[\"kpoint\"] = torch.from_numpy(kpoints).float().to(common_options[\"device\"])\n",
+ "\n",
+ "eigv = Eigenvalues(\n",
+ " idp=model.idp,\n",
+ " s_edge_field=AtomicDataDict.EDGE_OVERLAP_KEY,\n",
+ " s_node_field=AtomicDataDict.NODE_OVERLAP_KEY,\n",
+ " s_out_field=AtomicDataDict.OVERLAP_KEY,\n",
+ " device=common_options[\"device\"]\n",
+ " )\n",
+ "\n",
+ "model.eval()\n",
+ "\n",
+ "data_predict = model(data.copy()).copy() # edge field is rme\n",
+ "\n",
+ "# err = (eigv.h2k(data_predict.copy())[\"hamiltonian\"]-eigv.h2k(data.copy())[\"hamiltonian\"]).abs()\n",
+ "# plt.hist(err.flatten().detach().cpu(), bins=100, log=True)\n",
+ "# # plt.xscale(\"log\")\n",
+ "# plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data = eigv(data).copy()\n",
+ "data_predict[\"edge_overlap\"] = data[\"edge_overlap\"]\n",
+ "data_predict = eigv(data_predict)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "plt.matshow((data_predict[\"hamiltonian\"] - data[\"hamiltonian\"])[0].detach().abs().cpu().numpy(), cmap=\"bwr\", vmin=-0.5, vmax=0.5)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "plt.plot(xlist, data_predict[\"eigenvalue\"].detach().cpu()-data_predict[\"eigenvalue\"].detach().min().cpu(), c=\"tab:red\")\n",
+ "plt.plot(xlist, data[\"eigenvalue\"].detach().cpu()-data[\"eigenvalue\"].detach().min().cpu(), \"-.\", c=\"black\")\n",
+ "plt.ylim(0,6.5)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'klist': array([[ 0. , 0. , 0. ],\n",
+ " [ 0.01666667, 0. , 0. ],\n",
+ " [ 0.03333333, 0. , 0. ],\n",
+ " [ 0.05 , 0. , 0. ],\n",
+ " [ 0.06666667, 0. , 0. ],\n",
+ " [ 0.08333333, 0. , 0. ],\n",
+ " [ 0.1 , 0. , 0. ],\n",
+ " [ 0.11666667, 0. , 0. ],\n",
+ " [ 0.13333333, 0. , 0. ],\n",
+ " [ 0.15 , 0. , 0. ],\n",
+ " [ 0.16666667, 0. , 0. ],\n",
+ " [ 0.18333333, 0. , 0. ],\n",
+ " [ 0.2 , 0. , 0. ],\n",
+ " [ 0.21666667, 0. , 0. ],\n",
+ " [ 0.23333333, 0. , 0. ],\n",
+ " [ 0.25 , 0. , 0. ],\n",
+ " [ 0.26666667, 0. , 0. ],\n",
+ " [ 0.28333333, 0. , 0. ],\n",
+ " [ 0.3 , 0. , 0. ],\n",
+ " [ 0.31666667, 0. , 0. ],\n",
+ " [ 0.33333333, 0. , 0. ],\n",
+ " [ 0.35 , 0. , 0. ],\n",
+ " [ 0.36666667, 0. , 0. ],\n",
+ " [ 0.38333333, 0. , 0. ],\n",
+ " [ 0.4 , 0. , 0. ],\n",
+ " [ 0.41666667, 0. , 0. ],\n",
+ " [ 0.43333333, 0. , 0. ],\n",
+ " [ 0.45 , 0. , 0. ],\n",
+ " [ 0.46666667, 0. , 0. ],\n",
+ " [ 0.48333333, 0. , 0. ],\n",
+ " [ 0.5 , 0. , 0. ],\n",
+ " [ 0. , 0.5 , 0. ],\n",
+ " [ 0. , 0.48333333, 0. ],\n",
+ " [ 0. , 0.46666667, 0. ],\n",
+ " [ 0. , 0.45 , 0. ],\n",
+ " [ 0. , 0.43333333, 0. ],\n",
+ " [ 0. , 0.41666667, 0. ],\n",
+ " [ 0. , 0.4 , 0. ],\n",
+ " [ 0. , 0.38333333, 0. ],\n",
+ " [ 0. , 0.36666667, 0. ],\n",
+ " [ 0. , 0.35 , 0. ],\n",
+ " [ 0. , 0.33333333, 0. ],\n",
+ " [ 0. , 0.31666667, 0. ],\n",
+ " [ 0. , 0.3 , 0. ],\n",
+ " [ 0. , 0.28333333, 0. ],\n",
+ " [ 0. , 0.26666667, 0. ],\n",
+ " [ 0. , 0.25 , 0. ],\n",
+ " [ 0. , 0.23333333, 0. ],\n",
+ " [ 0. , 0.21666667, 0. ],\n",
+ " [ 0. , 0.2 , 0. ],\n",
+ " [ 0. , 0.18333333, 0. ],\n",
+ " [ 0. , 0.16666667, 0. ],\n",
+ " [ 0. , 0.15 , 0. ],\n",
+ " [ 0. , 0.13333333, 0. ],\n",
+ " [ 0. , 0.11666667, 0. ],\n",
+ " [ 0. , 0.1 , 0. ],\n",
+ " [ 0. , 0.08333333, 0. ],\n",
+ " [ 0. , 0.06666667, 0. ],\n",
+ " [ 0. , 0.05 , 0. ],\n",
+ " [ 0. , 0.03333333, 0. ],\n",
+ " [ 0. , 0.01666667, 0. ],\n",
+ " [ 0. , 0. , 0. ],\n",
+ " [ 0. , 0. , 0.01666667],\n",
+ " [ 0. , 0. , 0.03333333],\n",
+ " [ 0. , 0. , 0.05 ],\n",
+ " [ 0. , 0. , 0.06666667],\n",
+ " [ 0. , 0. , 0.08333333],\n",
+ " [ 0. , 0. , 0.1 ],\n",
+ " [ 0. , 0. , 0.11666667],\n",
+ " [ 0. , 0. , 0.13333333],\n",
+ " [ 0. , 0. , 0.15 ],\n",
+ " [ 0. , 0. , 0.16666667],\n",
+ " [ 0. , 0. , 0.18333333],\n",
+ " [ 0. , 0. , 0.2 ],\n",
+ " [ 0. , 0. , 0.21666667],\n",
+ " [ 0. , 0. , 0.23333333],\n",
+ " [ 0. , 0. , 0.25 ],\n",
+ " [ 0. , 0. , 0.26666667],\n",
+ " [ 0. , 0. , 0.28333333],\n",
+ " [ 0. , 0. , 0.3 ],\n",
+ " [ 0. , 0. , 0.31666667],\n",
+ " [ 0. , 0. , 0.33333333],\n",
+ " [ 0. , 0. , 0.35 ],\n",
+ " [ 0. , 0. , 0.36666667],\n",
+ " [ 0. , 0. , 0.38333333],\n",
+ " [ 0. , 0. , 0.4 ],\n",
+ " [ 0. , 0. , 0.41666667],\n",
+ " [ 0. , 0. , 0.43333333],\n",
+ " [ 0. , 0. , 0.45 ],\n",
+ " [ 0. , 0. , 0.46666667],\n",
+ " [ 0. , 0. , 0.48333333],\n",
+ " [ 0. , 0. , 0.5 ],\n",
+ " [-0.5 , -0.5 , 0.5 ],\n",
+ " [-0.48333333, -0.48333333, 0.48333333],\n",
+ " [-0.46666667, -0.46666667, 0.46666667],\n",
+ " [-0.45 , -0.45 , 0.45 ],\n",
+ " [-0.43333333, -0.43333333, 0.43333333],\n",
+ " [-0.41666667, -0.41666667, 0.41666667],\n",
+ " [-0.4 , -0.4 , 0.4 ],\n",
+ " [-0.38333333, -0.38333333, 0.38333333],\n",
+ " [-0.36666667, -0.36666667, 0.36666667],\n",
+ " [-0.35 , -0.35 , 0.35 ],\n",
+ " [-0.33333333, -0.33333333, 0.33333333],\n",
+ " [-0.31666667, -0.31666667, 0.31666667],\n",
+ " [-0.3 , -0.3 , 0.3 ],\n",
+ " [-0.28333333, -0.28333333, 0.28333333],\n",
+ " [-0.26666667, -0.26666667, 0.26666667],\n",
+ " [-0.25 , -0.25 , 0.25 ],\n",
+ " [-0.23333333, -0.23333333, 0.23333333],\n",
+ " [-0.21666667, -0.21666667, 0.21666667],\n",
+ " [-0.2 , -0.2 , 0.2 ],\n",
+ " [-0.18333333, -0.18333333, 0.18333333],\n",
+ " [-0.16666667, -0.16666667, 0.16666667],\n",
+ " [-0.15 , -0.15 , 0.15 ],\n",
+ " [-0.13333333, -0.13333333, 0.13333333],\n",
+ " [-0.11666667, -0.11666667, 0.11666667],\n",
+ " [-0.1 , -0.1 , 0.1 ],\n",
+ " [-0.08333333, -0.08333333, 0.08333333],\n",
+ " [-0.06666667, -0.06666667, 0.06666667],\n",
+ " [-0.05 , -0.05 , 0.05 ],\n",
+ " [-0.03333333, -0.03333333, 0.03333333],\n",
+ " [-0.01666667, -0.01666667, 0.01666667],\n",
+ " [ 0. , 0. , 0. ],\n",
+ " [ 0.01666667, -0.01666667, 0.01666667],\n",
+ " [ 0.03333333, -0.03333333, 0.03333333],\n",
+ " [ 0.05 , -0.05 , 0.05 ],\n",
+ " [ 0.06666667, -0.06666667, 0.06666667],\n",
+ " [ 0.08333333, -0.08333333, 0.08333333],\n",
+ " [ 0.1 , -0.1 , 0.1 ],\n",
+ " [ 0.11666667, -0.11666667, 0.11666667],\n",
+ " [ 0.13333333, -0.13333333, 0.13333333],\n",
+ " [ 0.15 , -0.15 , 0.15 ],\n",
+ " [ 0.16666667, -0.16666667, 0.16666667],\n",
+ " [ 0.18333333, -0.18333333, 0.18333333],\n",
+ " [ 0.2 , -0.2 , 0.2 ],\n",
+ " [ 0.21666667, -0.21666667, 0.21666667],\n",
+ " [ 0.23333333, -0.23333333, 0.23333333],\n",
+ " [ 0.25 , -0.25 , 0.25 ],\n",
+ " [ 0.26666667, -0.26666667, 0.26666667],\n",
+ " [ 0.28333333, -0.28333333, 0.28333333],\n",
+ " [ 0.3 , -0.3 , 0.3 ],\n",
+ " [ 0.31666667, -0.31666667, 0.31666667],\n",
+ " [ 0.33333333, -0.33333333, 0.33333333],\n",
+ " [ 0.35 , -0.35 , 0.35 ],\n",
+ " [ 0.36666667, -0.36666667, 0.36666667],\n",
+ " [ 0.38333333, -0.38333333, 0.38333333],\n",
+ " [ 0.4 , -0.4 , 0.4 ],\n",
+ " [ 0.41666667, -0.41666667, 0.41666667],\n",
+ " [ 0.43333333, -0.43333333, 0.43333333],\n",
+ " [ 0.45 , -0.45 , 0.45 ],\n",
+ " [ 0.46666667, -0.46666667, 0.46666667],\n",
+ " [ 0.48333333, -0.48333333, 0.48333333],\n",
+ " [ 0.5 , -0.5 , 0.5 ],\n",
+ " [-0.5 , 0. , 0.5 ],\n",
+ " [-0.48333333, 0. , 0.48333333],\n",
+ " [-0.46666667, 0. , 0.46666667],\n",
+ " [-0.45 , 0. , 0.45 ],\n",
+ " [-0.43333333, 0. , 0.43333333],\n",
+ " [-0.41666667, 0. , 0.41666667],\n",
+ " [-0.4 , 0. , 0.4 ],\n",
+ " [-0.38333333, 0. , 0.38333333],\n",
+ " [-0.36666667, 0. , 0.36666667],\n",
+ " [-0.35 , 0. , 0.35 ],\n",
+ " [-0.33333333, 0. , 0.33333333],\n",
+ " [-0.31666667, 0. , 0.31666667],\n",
+ " [-0.3 , 0. , 0.3 ],\n",
+ " [-0.28333333, 0. , 0.28333333],\n",
+ " [-0.26666667, 0. , 0.26666667],\n",
+ " [-0.25 , 0. , 0.25 ],\n",
+ " [-0.23333333, 0. , 0.23333333],\n",
+ " [-0.21666667, 0. , 0.21666667],\n",
+ " [-0.2 , 0. , 0.2 ],\n",
+ " [-0.18333333, 0. , 0.18333333],\n",
+ " [-0.16666667, 0. , 0.16666667],\n",
+ " [-0.15 , 0. , 0.15 ],\n",
+ " [-0.13333333, 0. , 0.13333333],\n",
+ " [-0.11666667, 0. , 0.11666667],\n",
+ " [-0.1 , 0. , 0.1 ],\n",
+ " [-0.08333333, 0. , 0.08333333],\n",
+ " [-0.06666667, 0. , 0.06666667],\n",
+ " [-0.05 , 0. , 0.05 ],\n",
+ " [-0.03333333, 0. , 0.03333333],\n",
+ " [-0.01666667, 0. , 0.01666667],\n",
+ " [ 0. , 0. , 0. ],\n",
+ " [ 0.01666667, -0.01666667, 0. ],\n",
+ " [ 0.03333333, -0.03333333, 0. ],\n",
+ " [ 0.05 , -0.05 , 0. ],\n",
+ " [ 0.06666667, -0.06666667, 0. ],\n",
+ " [ 0.08333333, -0.08333333, 0. ],\n",
+ " [ 0.1 , -0.1 , 0. ],\n",
+ " [ 0.11666667, -0.11666667, 0. ],\n",
+ " [ 0.13333333, -0.13333333, 0. ],\n",
+ " [ 0.15 , -0.15 , 0. ],\n",
+ " [ 0.16666667, -0.16666667, 0. ],\n",
+ " [ 0.18333333, -0.18333333, 0. ],\n",
+ " [ 0.2 , -0.2 , 0. ],\n",
+ " [ 0.21666667, -0.21666667, 0. ],\n",
+ " [ 0.23333333, -0.23333333, 0. ],\n",
+ " [ 0.25 , -0.25 , 0. ],\n",
+ " [ 0.26666667, -0.26666667, 0. ],\n",
+ " [ 0.28333333, -0.28333333, 0. ],\n",
+ " [ 0.3 , -0.3 , 0. ],\n",
+ " [ 0.31666667, -0.31666667, 0. ],\n",
+ " [ 0.33333333, -0.33333333, 0. ],\n",
+ " [ 0.35 , -0.35 , 0. ],\n",
+ " [ 0.36666667, -0.36666667, 0. ],\n",
+ " [ 0.38333333, -0.38333333, 0. ],\n",
+ " [ 0.4 , -0.4 , 0. ],\n",
+ " [ 0.41666667, -0.41666667, 0. ],\n",
+ " [ 0.43333333, -0.43333333, 0. ],\n",
+ " [ 0.45 , -0.45 , 0. ],\n",
+ " [ 0.46666667, -0.46666667, 0. ],\n",
+ " [ 0.48333333, -0.48333333, 0. ],\n",
+ " [ 0.5 , -0.5 , 0. ]]),\n",
+ " 'xlist': array([0. , 0.00369795, 0.0073959 , 0.01109385, 0.01479181,\n",
+ " 0.01848976, 0.02218771, 0.02588566, 0.02958361, 0.03328156,\n",
+ " 0.03697951, 0.04067746, 0.04437542, 0.04807337, 0.05177132,\n",
+ " 0.05546927, 0.05916722, 0.06286517, 0.06656312, 0.07026108,\n",
+ " 0.07395903, 0.07765698, 0.08135493, 0.08505288, 0.08875083,\n",
+ " 0.09244878, 0.09614674, 0.09984469, 0.10354264, 0.10724059,\n",
+ " 0.11093854, 0.11093854, 0.11463649, 0.11833444, 0.12203239,\n",
+ " 0.12573035, 0.1294283 , 0.13312625, 0.1368242 , 0.14052215,\n",
+ " 0.1442201 , 0.14791805, 0.15161601, 0.15531396, 0.15901191,\n",
+ " 0.16270986, 0.16640781, 0.17010576, 0.17380371, 0.17750167,\n",
+ " 0.18119962, 0.18489757, 0.18859552, 0.19229347, 0.19599142,\n",
+ " 0.19968937, 0.20338732, 0.20708528, 0.21078323, 0.21448118,\n",
+ " 0.21817913, 0.22187708, 0.22557503, 0.22927298, 0.23297094,\n",
+ " 0.23666889, 0.24036684, 0.24406479, 0.24776274, 0.25146069,\n",
+ " 0.25515864, 0.2588566 , 0.26255455, 0.2662525 , 0.26995045,\n",
+ " 0.2736484 , 0.27734635, 0.2810443 , 0.28474225, 0.28844021,\n",
+ " 0.29213816, 0.29583611, 0.29953406, 0.30323201, 0.30692996,\n",
+ " 0.31062791, 0.31432587, 0.31802382, 0.32172177, 0.32541972,\n",
+ " 0.32911767, 0.33281562, 0.33281562, 0.33922066, 0.3456257 ,\n",
+ " 0.35203074, 0.35843578, 0.36484082, 0.37124586, 0.3776509 ,\n",
+ " 0.38405594, 0.39046098, 0.39686602, 0.40327106, 0.4096761 ,\n",
+ " 0.41608114, 0.42248618, 0.42889122, 0.43529626, 0.4417013 ,\n",
+ " 0.44810634, 0.45451138, 0.46091642, 0.46732145, 0.47372649,\n",
+ " 0.48013153, 0.48653657, 0.49294161, 0.49934665, 0.50575169,\n",
+ " 0.51215673, 0.51856177, 0.52496681, 0.53137185, 0.53777689,\n",
+ " 0.54418193, 0.55058697, 0.55699201, 0.56339705, 0.56980209,\n",
+ " 0.57620713, 0.58261217, 0.58901721, 0.59542225, 0.60182729,\n",
+ " 0.60823233, 0.61463737, 0.62104241, 0.62744745, 0.63385249,\n",
+ " 0.64025753, 0.64666256, 0.6530676 , 0.65947264, 0.66587768,\n",
+ " 0.67228272, 0.67868776, 0.6850928 , 0.69149784, 0.69790288,\n",
+ " 0.70430792, 0.71071296, 0.717118 , 0.717118 , 0.72234769,\n",
+ " 0.72757739, 0.73280708, 0.73803677, 0.74326647, 0.74849616,\n",
+ " 0.75372585, 0.75895554, 0.76418524, 0.76941493, 0.77464462,\n",
+ " 0.77987432, 0.78510401, 0.7903337 , 0.7955634 , 0.80079309,\n",
+ " 0.80602278, 0.81125247, 0.81648217, 0.82171186, 0.82694155,\n",
+ " 0.83217125, 0.83740094, 0.84263063, 0.84786032, 0.85309002,\n",
+ " 0.85831971, 0.8635494 , 0.8687791 , 0.87400879, 0.87923848,\n",
+ " 0.88446818, 0.88969787, 0.89492756, 0.90015725, 0.90538695,\n",
+ " 0.91061664, 0.91584633, 0.92107603, 0.92630572, 0.93153541,\n",
+ " 0.93676511, 0.9419948 , 0.94722449, 0.95245418, 0.95768388,\n",
+ " 0.96291357, 0.96814326, 0.97337296, 0.97860265, 0.98383234,\n",
+ " 0.98906204, 0.99429173, 0.99952142, 1.00475111, 1.00998081,\n",
+ " 1.0152105 , 1.02044019, 1.02566989, 1.03089958]),\n",
+ " 'high_sym_kpoints': array([0. , 0.11093854, 0.11093854, 0.22187708, 0.33281562,\n",
+ " 0.33281562, 0.52496681, 0.717118 , 0.717118 , 0.87400879,\n",
+ " 1.03089958]),\n",
+ " 'labels': ['G',\n",
+ " 'X/Y',\n",
+ " 'X/Y',\n",
+ " 'G',\n",
+ " 'Z',\n",
+ " 'R_2',\n",
+ " 'G',\n",
+ " 'T_2/U_2',\n",
+ " 'T_2/U_2',\n",
+ " 'G',\n",
+ " 'V_2'],\n",
+ " 'eigenvalues': array([[-30.787792 , -14.037892 , -13.212245 , ..., 89.322876 ,\n",
+ " 89.63834 , 90.714935 ],\n",
+ " [-30.78349 , -14.038205 , -13.209134 , ..., 89.28097 ,\n",
+ " 89.61049 , 90.682625 ],\n",
+ " [-30.77045 , -14.039989 , -13.2008095, ..., 89.14731 ,\n",
+ " 89.532074 , 90.58845 ],\n",
+ " ...,\n",
+ " [-17.320847 , -15.781858 , -15.243708 , ..., 91.68263 ,\n",
+ " 92.17371 , 97.48687 ],\n",
+ " [-16.845543 , -15.6644535, -15.250412 , ..., 91.75847 ,\n",
+ " 92.22618 , 95.48818 ],\n",
+ " [-16.674685 , -15.5257015, -15.14295 , ..., 91.79529 ,\n",
+ " 92.21178 , 94.452545 ]], dtype=float32),\n",
+ " 'E_fermi': None}"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from dptb.postprocess.bandstructure.band import Band\n",
+ "\n",
+ "band = Band(\n",
+ " model=model,\n",
+ " use_gui=True,\n",
+ " device=common_options[\"device\"],\n",
+ " overlap=False,\n",
+ ")\n",
+ "\n",
+ "kpts = np.array([[0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.5000000000, 0.0000000000, 0.0000000000, 1], \n",
+ " [0.0000000000, 0.5000000000, 0.0000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.5000000000, 1], \n",
+ " [-0.500000000, -0.500000000, 0.5000000000, 30], \n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30], \n",
+ " [0.5000000000, -0.500000000, 0.5000000000, 1],\n",
+ " [-0.500000000, 0.0000000000, 0.5000000000, 30],\n",
+ " [0.0000000000, 0.0000000000, 0.0000000000, 30],\n",
+ " [0.5000000000, -0.500000000, 0.0000000000, 1 ],\n",
+ " ])\n",
+ "\n",
+ "band.get_bands(\n",
+ " data=train_dataset[0], \n",
+ " kpath_kwargs={\n",
+ " \"kline_type\": \"abacus\",\n",
+ " \"kpath\":kpts, \n",
+ " \"klabels\": [\"G\", \"X/Y\", \"X/Y\", \"G\", \"Z\", \"R_2\", \"G\", \"T_2/U_2\", \"T_2/U_2\", \"G\", \"V_2\"]\n",
+ " }\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "band.band_plot(E_fermi=0.)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "band.band_plot(E_fermi=0.)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "deeptb",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.13"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/dptb/plugins/base_plugin.py b/dptb/plugins/base_plugin.py
index afdd0691..08c44cec 100644
--- a/dptb/plugins/base_plugin.py
+++ b/dptb/plugins/base_plugin.py
@@ -28,8 +28,8 @@ def __init__(self) -> None:
self.stats = {} # the status of Trainer.
self.plugin_queues = {'disposable': [], 'iteration': [], 'epoch': [], 'batch': [], 'update': []}
- def register_plugin(self, plugin):
- plugin.register(self)
+ def register_plugin(self, plugin, **kwargs):
+ plugin.register(self, **kwargs)
# the trigger interval of plugin, with the form like: [(1, 'iteration'), (1, 'epoch')]
intervals = plugin.trigger_interval
diff --git a/dptb/plugins/monitor.py b/dptb/plugins/monitor.py
index bdedb79a..75e739e1 100644
--- a/dptb/plugins/monitor.py
+++ b/dptb/plugins/monitor.py
@@ -1,6 +1,8 @@
from dptb.plugins.base_plugin import Plugin
import logging
import time
+import torch
+from dptb.data import AtomicData
log = logging.getLogger(__name__)
@@ -96,6 +98,10 @@ class TrainLossMonitor(Monitor):
# It's a Monitor that records the loss.
# stat_name is used in the Monitor class to register.
stat_name = 'train_loss'
+ def __init__(self):
+ super(TrainLossMonitor, self).__init__(
+ precision=7,
+ )
def _get_value(self, **kwargs):
return kwargs.get('train_loss', None)
@@ -117,11 +123,12 @@ def __init__(self):
def _get_value(self, **kwargs):
return kwargs.get('lr', None)
+
class Validationer(Monitor):
stat_name = 'validation_loss'
def _get_value(self, **kwargs):
if kwargs.get('field') == "iteration":
- return self.trainer.validation(quick=True)
+ return self.trainer.validation(fast=True)
else:
- return self.trainer.validation()
+ return self.trainer.validation()
\ No newline at end of file
diff --git a/dptb/plugins/plugins.py b/dptb/plugins/plugins.py
index 152d5ddb..983a9e0b 100644
--- a/dptb/plugins/plugins.py
+++ b/dptb/plugins/plugins.py
@@ -14,83 +14,126 @@ def __init__(self, interval=None):
interval = [(1, 'iteration'), (1, 'epoch')]
super(Saver, self).__init__(interval)
self.best_loss = 1e7
+ self.best_quene = []
- def register(self, trainer):
- self.checkpoint_path = trainer.run_opt["checkpoint_path"]
+ def register(self, trainer, checkpoint_path):
+ self.checkpoint_path = checkpoint_path
self.trainer = trainer
def iteration(self, **kwargs):
- suffix = "_b"+"%.3f"%self.trainer.common_options["bond_cutoff"]+"_c"+"%.3f"%self.trainer.model_options["skfunction"]["sk_cutoff"]+"_w"+\
- "%.3f"%self.trainer.model_options["skfunction"]["sk_decay_w"]
- self._save(name="latest_"+self.trainer.name+suffix,model=self.trainer.model,model_config=self.trainer.model_config)
- if self.trainer.name == "dptb" \
- and self.trainer.run_opt["use_correction"] \
- and not self.trainer.run_opt["freeze"]:
-
- self._save(name="latest_"+self.trainer.name+'_nnsk'+suffix,model=self.trainer.sknet, model_config=self.trainer.sknet_config)
+ # suffix = "_b"+"%.3f"%self.trainer.common_options["bond_cutoff"]+"_c"+"%.3f"%self.trainer.onsite_options["skfunction"]["sk_cutoff"]+"_w"+\
+ # "%.3f"%self.trainer.model_options["skfunction"]["sk_decay_w"]
+ suffix = ".iter{}".format(self.trainer.iter+1)
+ self._save(
+ name=self.trainer.model.name+suffix,
+ model=self.trainer.model,
+ model_options=self.trainer.model.model_options,
+ common_options=self.trainer.common_options,
+ train_options=self.trainer.train_options,
+ )
+
+ # if self.trainer.name == "dptb" \
+ # and self.trainer.run_opt["use_correction"] \
+ # and not self.trainer.run_opt["freeze"]:
+
+ # self._save(name="latest_"+self.trainer.name+'_nnsk'+suffix,model=self.trainer.sknet, model_config=self.trainer.sknet_config)
def epoch(self, **kwargs):
- if self.trainer.stats.get('validation_loss').get('last',1e6) < self.best_loss:
- suffix = "_b"+"%.3f"%self.trainer.common_options["bond_cutoff"]+"_c"+"%.3f"%self.trainer.model_options["skfunction"]["sk_cutoff"]+"_w"+\
- "%.3f"%self.trainer.model_options["skfunction"]["sk_decay_w"]
- self._save(name="best_"+self.trainer.name+suffix,model=self.trainer.model,model_config=self.trainer.model_config)
- self.best_loss = self.trainer.stats['validation_loss'].get('last',1e6)
- if self.trainer.name == "dptb" \
- and self.trainer.run_opt["use_correction"] \
- and not self.trainer.run_opt["freeze"]:
+ updated_loss = self.trainer.stats.get('validation_loss')
+ if updated_loss is not None:
+ updated_loss = updated_loss.get('epoch_mean',1e6)
+ else:
+ updated_loss = self.trainer.stats.get("train_loss").get("epoch_mean",1e6)
+
+
+ if updated_loss < self.best_loss:
+ # suffix = "_b"+"%.3f"%self.trainer.common_options["bond_cutoff"]+"_c"+"%.3f"%self.trainer.model_options["skfunction"]["sk_cutoff"]+"_w"+\
+ # "%.3f"%self.trainer.model_options["skfunction"]["sk_decay_w"]
+ suffix = ".ep{}".format(self.trainer.ep+1)
+ name = self.trainer.model.name+suffix
+ self.best_quene.append(name)
+ if len(self.best_quene) >= 5:
+ delete_name = self.best_quene.pop(0)
+ delete_path = os.path.join(self.checkpoint_path, delete_name+".pth")
+ os.remove(delete_path)
+
+ self._save(
+ name=name,
+ model=self.trainer.model,
+ model_options=self.trainer.model.model_options,
+ common_options=self.trainer.common_options,
+ train_options=self.trainer.train_options,
+ )
+
+ self.best_loss = updated_loss
+
+ # if self.trainer.name == "dptb" \
+ # and self.trainer.run_opt["use_correction"] \
+ # and not self.trainer.run_opt["freeze"]:
- self._save(name="best_"+self.trainer.name+'_nnsk'+suffix,model=self.trainer.sknet, model_config=self.trainer.sknet_config)
+ # self._save(
+ # name="best_"+self.trainer.name+'_nnsk'+suffix,
+ # model=self.trainer.sknet,
+ # model_config=self.trainer.sknet_config
+ # common_options=self.trainer.common_options
+ # )
# log.info(msg="checkpoint saved as {}".format("best_epoch"))
- def _save(self, name, model, model_config):
+ def _save(self, name, model, model_options, common_options, train_options):
obj = {}
- model_config["dtype"] = str(model_config["dtype"]).split('.')[-1]
- obj.update({"model_config":model_config, "model_state_dict": model.state_dict(),
- "optimizer_state_dict": self.trainer.optimizer.state_dict(), "epoch": self.trainer.epoch+1,
- "iteration":self.trainer.iteration+1, "stats": self.trainer.stats})
+ obj.update({"config": {"model_options": model_options, "common_options": common_options, "train_options": train_options}})
+ obj.update(
+ {
+ "model_state_dict": model.state_dict(),
+ "optimizer_state_dict": self.trainer.optimizer.state_dict(),
+ "lr_scheduler_state_dict": self.trainer.lr_scheduler.state_dict(),
+ "epoch": self.trainer.ep+1,
+ "iteration":self.trainer.iter+1,
+ "stats": self.trainer.stats}
+ )
f_path = os.path.join(self.checkpoint_path, name+".pth")
torch.save(obj, f=f_path)
- # json_model_types = ["onsite", "hopping","soc"]
- if self.trainer.name == "nnsk":
- json_data = {}
- onsitecoeff = {}
- hoppingcoeff = {}
- if self.trainer.onsitemode == "strain":
- for i in self.trainer.onsite_coeff:
- onsitecoeff[i] = self.trainer.onsite_coeff[i].tolist()
- elif self.trainer.onsitemode in ['uniform','split']:
- for ia in self.trainer.onsite_coeff:
- for iikey in range(len(self.trainer.onsite_index_dict[ia])):
- onsitecoeff[self.trainer.onsite_index_dict[ia][iikey]] = \
- [self.trainer.onsite_coeff[ia].tolist()[iikey]]
- elif self.trainer.onsitemode == 'NRL':
- for i in self.trainer.onsite_coeff:
- onsitecoeff[i] = self.trainer.onsite_coeff[i].tolist()
+ # # json_model_types = ["onsite", "hopping","soc"]
+ # if self.trainer.name == "nnsk":
+ # json_data = {}
+ # onsitecoeff = {}
+ # hoppingcoeff = {}
+ # if self.trainer.onsitemode == "strain":
+ # for i in self.trainer.onsite_coeff:
+ # onsitecoeff[i] = self.trainer.onsite_coeff[i].tolist()
+ # elif self.trainer.onsitemode in ['uniform','split']:
+ # for ia in self.trainer.onsite_coeff:
+ # for iikey in range(len(self.trainer.onsite_index_dict[ia])):
+ # onsitecoeff[self.trainer.onsite_index_dict[ia][iikey]] = \
+ # [self.trainer.onsite_coeff[ia].tolist()[iikey]]
+ # elif self.trainer.onsitemode == 'NRL':
+ # for i in self.trainer.onsite_coeff:
+ # onsitecoeff[i] = self.trainer.onsite_coeff[i].tolist()
- json_data["onsite"] = onsitecoeff
- for i in self.trainer.hopping_coeff:
- hoppingcoeff[i] = self.trainer.hopping_coeff[i].tolist()
- json_data["hopping"] = hoppingcoeff
-
- if self.trainer.overlap_coeff is not None:
- overlapcoeff = {}
- for i in self.trainer.overlap_coeff:
- overlapcoeff[i] = self.trainer.overlap_coeff[i].tolist()
- json_data["overlap"] = overlapcoeff
+ # json_data["onsite"] = onsitecoeff
+ # for i in self.trainer.hopping_coeff:
+ # hoppingcoeff[i] = self.trainer.hopping_coeff[i].tolist()
+ # json_data["hopping"] = hoppingcoeff
+
+ # if self.trainer.overlap_coeff is not None:
+ # overlapcoeff = {}
+ # for i in self.trainer.overlap_coeff:
+ # overlapcoeff[i] = self.trainer.overlap_coeff[i].tolist()
+ # json_data["overlap"] = overlapcoeff
- if hasattr(self.trainer,'soc_coeff'):
- soccoeff = {}
- for ia in self.trainer.soc_coeff:
- for iikey in range(len(self.trainer.onsite_index_dict[ia])):
- soccoeff[self.trainer.onsite_index_dict[ia][iikey]] = \
- [self.trainer.soc_coeff[ia].tolist()[iikey]]
- json_data["soc"] = soccoeff
- json_path = os.path.join(self.checkpoint_path, name+".json")
- with open(json_path, "w") as f:
- json.dump(json_data, f, indent=4)
+ # if hasattr(self.trainer,'soc_coeff'):
+ # soccoeff = {}
+ # for ia in self.trainer.soc_coeff:
+ # for iikey in range(len(self.trainer.onsite_index_dict[ia])):
+ # soccoeff[self.trainer.onsite_index_dict[ia][iikey]] = \
+ # [self.trainer.soc_coeff[ia].tolist()[iikey]]
+ # json_data["soc"] = soccoeff
+ # json_path = os.path.join(self.checkpoint_path, name+".json")
+ # with open(json_path, "w") as f:
+ # json.dump(json_data, f, indent=4)
log.info(msg="checkpoint saved as {}".format(name))
diff --git a/dptb/postprocess/bandstructure/band.py b/dptb/postprocess/bandstructure/band.py
index e9d10d1c..c0d85f3e 100644
--- a/dptb/postprocess/bandstructure/band.py
+++ b/dptb/postprocess/bandstructure/band.py
@@ -3,11 +3,16 @@
from dptb.utils.make_kpoints import ase_kpath, abacus_kpath, vasp_kpath
from ase.io import read
import ase
+from typing import Union
import matplotlib.pyplot as plt
+import torch
+from typing import Optional
import matplotlib
import logging
log = logging.getLogger(__name__)
from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+from dptb.data import AtomicData, AtomicDataDict
+from dptb.nn.energy import Eigenvalues
class bandcalc(object):
def __init__ (self, apiHrk, run_opt, jdata):
@@ -156,3 +161,196 @@ def band_plot(self):
plt.savefig(f'{self.results_path}/band.png',dpi=300)
if self.use_gui:
plt.show()
+
+
+class Band(object):
+ def __init__ (
+ self,
+ model: torch.nn.Module,
+ results_path: Optional[str]=None,
+ use_gui=False,
+ overlap=False,
+ device: Union[str, torch.device]=torch.device('cpu')
+ ):
+
+ if isinstance(device, str):
+ device = torch.device(device)
+ self.device = device
+ self.model = model
+ self.model.eval()
+ self.use_gui = use_gui
+ self.results_path = results_path
+ self.overlap = overlap
+
+ if overlap:
+ self.eigv = Eigenvalues(
+ idp=model.idp,
+ device=self.device,
+ s_edge_field=AtomicDataDict.EDGE_OVERLAP_KEY,
+ s_node_field=AtomicDataDict.NODE_OVERLAP_KEY,
+ s_out_field=AtomicDataDict.OVERLAP_KEY,
+ dtype=model.dtype,
+ )
+ else:
+ self.eigv = Eigenvalues(
+ idp=model.idp,
+ device=self.device,
+ dtype=model.dtype,
+ )
+
+ def get_bands(self, data: Union[AtomicData, ase.Atoms, str], kpath_kwargs: dict, AtomicData_options: dict={}):
+ kline_type = kpath_kwargs['kline_type']
+
+ # get the AtomicData structure and the ase structure
+ if isinstance(data, str):
+ structase = read(data)
+ data = AtomicData.from_ase(structase, **AtomicData_options)
+ elif isinstance(data, ase.Atoms):
+ structase = data
+ data = AtomicData.from_ase(structase, **AtomicData_options)
+ elif isinstance(data, AtomicData):
+ structase = data.to_ase()
+ data = data
+
+
+ data = AtomicData.to_AtomicDataDict(data.to(self.device))
+ data = self.model.idp(data)
+
+ if self.overlap == True:
+ assert data.get(AtomicDataDict.EDGE_OVERLAP_KEY) is not None
+
+
+ if kline_type == 'ase':
+ kpath = kpath_kwargs['kpath']
+ nkpoints = kpath_kwargs['nkpoints']
+ klist, xlist, high_sym_kpoints, labels = ase_kpath(structase=structase, pathstr=kpath, total_nkpoints=nkpoints)
+
+ elif kline_type == 'abacus':
+ kpath = kpath_kwargs['kpath']
+ labels = kpath_kwargs['klabels']
+ klist, xlist, high_sym_kpoints = abacus_kpath(structase=structase, kpath=kpath)
+
+ elif kline_type == 'vasp':
+ kpath = kpath_kwargs['kpath']
+ high_sym_kpoints_dict = kpath_kwargs['high_sym_kpoints']
+ number_in_line = kpath_kwargs['number_in_line']
+ klist, xlist, high_sym_kpoints, labels = vasp_kpath(structase=structase,
+ pathstr=kpath, high_sym_kpoints_dict=high_sym_kpoints_dict, number_in_line=number_in_line)
+ else:
+ log.error('Error, now, kline_type only support ase_kpath, abacus, or vasp.')
+ raise ValueError
+
+ # set the kpoint of the AtomicData
+ data[AtomicDataDict.KPOINT_KEY] = torch.as_tensor(klist, dtype=self.model.dtype, device=self.device)
+
+ # get the eigenvalues
+ data = self.model(data)
+ data = self.eigv(data)
+
+ # get the E_fermi from data
+ estimated_E_fermi = None
+
+ self.eigenstatus = {'klist': klist,
+ 'xlist': xlist,
+ 'high_sym_kpoints': high_sym_kpoints,
+ 'labels': labels,
+ 'eigenvalues': data[AtomicDataDict.ENERGY_EIGENVALUE_KEY].detach().cpu().numpy(),
+ 'E_fermi': estimated_E_fermi}
+
+ if self.results_path is not None:
+ np.save(f'{self.results_path}/bandstructure',self.eigenstatus)
+
+ return self.eigenstatus
+
+ def band_plot(
+ self,
+ ref_band: Union[str, np.array, torch.Tensor, bool]=None,
+ E_fermi: Optional[float]=None,
+ emin: Optional[float]=None,
+ emax: Optional[float]=None,
+ ):
+
+ if isinstance(ref_band, str):
+ ref_band = np.load(ref_band)
+
+ if E_fermi != None and self.eigenstatus["E_fermi"] != E_fermi:
+ log.info(f'use input fermi energy: {E_fermi}, While the estimated value in line-mode is {self.eigenstatus["E_fermi"]}')
+ else:
+ E_fermi = self.eigenstatus["E_fermi"]
+ log.info(f'The fermi energy is not provided, use the estimated value in line-mode: {self.eigenstatus["E_fermi"]}')
+
+ matplotlib.rcParams['font.size'] = 7
+ matplotlib.rcParams['pdf.fonttype'] = 42
+ # plt.rcParams['font.sans-serif'] = ['Times New Roman']
+
+ fig = plt.figure(figsize=(4.5,4),dpi=100)
+
+ ax = fig.add_subplot(111)
+
+ band_color = '#5d5d5d'
+ # plot the line
+
+ if ref_band is not None:
+ if len(ref_band.shape) == 3:
+ assert ref_band.shape[0] == 1
+ ref_band = ref_band.reshape(ref_band.shape[1:])
+ elif len(ref_band.shape) != 2:
+ log.error("Reference Eigenvalues' shape mismatch.")
+ raise ValueError
+
+ if ref_band.shape[0] != self.eigenstatus["eigenvalues"].shape[0]:
+ log.error("Reference Eigenvalues' should have sampled from the sample kpath as model's prediction.")
+ raise ValueError
+ ref_band = ref_band - (np.min(ref_band) - np.min(self.eigenstatus["eigenvalues"]))
+
+ nkplot = (len(np.unique(self.eigenstatus["high_sym_kpoints"]))-1) * 7
+ nintp = len(self.eigenstatus["xlist"]) // nkplot
+ if nintp == 0:
+ nintp = 1
+ band_ref = ax.plot(self.eigenstatus["xlist"][::nintp], ref_band[::nintp] - E_fermi, 'o', ms=4, color=band_color, alpha=0.8, label="Ref")
+ band_pre = ax.plot(self.eigenstatus["xlist"], self.eigenstatus["eigenvalues"] - E_fermi, color="tab:red", lw=1.5, alpha=0.8, label="DeePTB")
+
+ else:
+ ax.plot(self.eigenstatus["xlist"], self.eigenstatus["eigenvalues"] - E_fermi, color="tab:red",lw=1.5, alpha=0.8)
+
+ # add verticle line
+ for ii in self.eigenstatus["high_sym_kpoints"][1:-1]:
+ ax.axvline(ii, color='gray', lw=1,ls='--')
+
+ # add shadow
+ # for i in range(self.eigenvalues.shape[1]):
+ # ax.fill_between(self.xlist, self.eigenvalues[:,i] - self.E_fermi, -2, alpha=0.05, color=band_color)
+ # add ticks
+
+ if not (emin is None or emax is None):
+ ax.set_ylim(emin,emax)
+
+ ax.set_xlim(self.eigenstatus["xlist"].min()-0.03,self.eigenstatus["xlist"].max()+0.03)
+ ax.set_ylabel('E - EF (eV)',fontsize=12)
+ ax.yaxis.set_minor_locator(MultipleLocator(1.0))
+ ax.tick_params(which='both', direction='in', labelsize=12, width=1.5)
+ ax.tick_params(which='major', length=6)
+ ax.tick_params(which='minor', length=4, color='gray')
+
+ # ax.set_yticks(None, fontsize=12)
+ ax.set_xticks(self.eigenstatus["high_sym_kpoints"], self.eigenstatus["labels"], fontsize=12)
+
+ ax.grid(color='gray', alpha=0.2, linestyle='-', linewidth=1)
+ ax.set_axisbelow(True)
+
+ fig.patch.set_facecolor('#f2f2f2')
+ fig.patch.set_alpha(1)
+ for spine in ax.spines.values():
+ spine.set_edgecolor('#5d5d5d')
+ spine.set_linewidth(1.5)
+
+ if ref_band is not None:
+ plt.legend(handles=[band_pre[0], band_ref[0]], loc="best")
+
+ plt.tight_layout()
+ # remove the box around the plot
+ ax.set_frame_on(False)
+ if self.results_path is not None:
+ plt.savefig(f'{self.results_path}/band.png',dpi=300)
+ if self.use_gui:
+ plt.show()
diff --git a/dptb/tests/data/test_sktb/dataset/kpath_spk.0/info.json b/dptb/tests/data/test_sktb/dataset/kpath_spk.0/info.json
new file mode 100644
index 00000000..d2d7bd90
--- /dev/null
+++ b/dptb/tests/data/test_sktb/dataset/kpath_spk.0/info.json
@@ -0,0 +1,19 @@
+{
+ "nframes": 1,
+ "natoms": 2,
+ "pos_type": "ase",
+ "AtomicData_options": {
+ "r_max": 5.0,
+ "er_max": 5.0,
+ "oer_max": 2.5,
+ "pbc": true
+ },
+ "bandinfo": {
+ "nkpoints": 61,
+ "nbands": 14,
+ "band_min": 0,
+ "band_max": 6,
+ "emin": null,
+ "emax": null
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/dataset/kpathmd25.0/info.json b/dptb/tests/data/test_sktb/dataset/kpathmd25.0/info.json
new file mode 100644
index 00000000..6485de04
--- /dev/null
+++ b/dptb/tests/data/test_sktb/dataset/kpathmd25.0/info.json
@@ -0,0 +1,17 @@
+{
+ "nframes": 10,
+ "natoms": 8,
+ "pos_type": "ase",
+ "AtomicData_options": {
+ "r_max": 5.0,
+ "er_max": 5.0,
+ "oer_max": 2.5,
+ "pbc": true
+ },
+ "bandinfo": {
+ "band_min": 0,
+ "band_max": 8,
+ "emin": null,
+ "emax": null
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_dptb.json b/dptb/tests/data/test_sktb/input/input_dptb.json
new file mode 100644
index 00000000..1bc42b9e
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_dptb.json
@@ -0,0 +1,54 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p", "d*"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "train_options": {
+ "num_epoch": 1500,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.001,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 500,
+ "validation_freq": 10,
+ "display_freq": 100
+ },
+ "model_options": {
+ "embedding":{
+ "method": "se2",
+ "rs": 2.5,
+ "rc": 5.0,
+ "radial_net": {
+ "neurons": [10,20,30]
+ }
+ },
+ "prediction":{
+ "method": "sktb",
+ "neurons": [16,16,16]
+ },
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":2.5 ,"w":0.3},
+ "hopping": {"method": "powerlaw", "rs":5.0, "w": 0.1},
+ "freeze": true
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./data/",
+ "prefix": "kpath_spk",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_md.json b/dptb/tests/data/test_sktb/input/input_md.json
new file mode 100644
index 00000000..d40dbe74
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_md.json
@@ -0,0 +1,42 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p", "d*"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "train_options": {
+ "num_epoch": 2,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.01,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 500,
+ "validation_freq": 10,
+ "display_freq": 100
+ },
+ "model_options": {
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":2.5 ,"w":0.3},
+ "hopping": {"method": "powerlaw", "rs":2.6, "w": 0.35},
+ "freeze": false
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./dptb/tests/data/test_sktb/dataset/",
+ "prefix": "kpathmd25",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_push_rs.json b/dptb/tests/data/test_sktb/input/input_push_rs.json
new file mode 100644
index 00000000..40d8b6f1
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_push_rs.json
@@ -0,0 +1,42 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p", "d*"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "train_options": {
+ "num_epoch": 10,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.01,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 1,
+ "display_freq": 100
+ },
+ "model_options": {
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":2.5 ,"w":0.3},
+ "hopping": {"method": "powerlaw", "rs":2.6, "w": 0.3},
+ "freeze": false,
+ "push": {"rs_thr": 0.01, "period": 1}
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./dptb/tests/data/test_sktb/dataset/",
+ "prefix": "kpath_spk",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_push_w.json b/dptb/tests/data/test_sktb/input/input_push_w.json
new file mode 100644
index 00000000..77e56525
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_push_w.json
@@ -0,0 +1,42 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p", "d*"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "train_options": {
+ "num_epoch": 10,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.05,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 1,
+ "display_freq": 100
+ },
+ "model_options": {
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":2.5 ,"w":0.3},
+ "hopping": {"method": "powerlaw", "rs":5.0, "w": 0.3},
+ "freeze": false,
+ "push": {"w_thr": 0.01, "period": 1}
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./dptb/tests/data/test_sktb/dataset/",
+ "prefix": "kpath_spk",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_strain_polar.json b/dptb/tests/data/test_sktb/input/input_strain_polar.json
new file mode 100644
index 00000000..ea623641
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_strain_polar.json
@@ -0,0 +1,41 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p", "d*"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "train_options": {
+ "num_epoch": 5,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.05,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 1,
+ "display_freq": 100
+ },
+ "model_options": {
+ "nnsk": {
+ "onsite": {"method": "strain", "rs":2.5 ,"w":0.3},
+ "hopping": {"method": "powerlaw", "rs":2.6, "w": 0.3},
+ "freeze": false
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./dptb/tests/data/test_sktb/dataset/",
+ "prefix": "kpath_spk",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/data/test_sktb/input/input_valence.json b/dptb/tests/data/test_sktb/input/input_valence.json
new file mode 100644
index 00000000..d9e1005a
--- /dev/null
+++ b/dptb/tests/data/test_sktb/input/input_valence.json
@@ -0,0 +1,42 @@
+{
+ "common_options": {
+ "basis": {
+ "Si": ["3s", "3p"]
+ },
+ "device": "cpu",
+ "dtype": "float32",
+ "overlap": false,
+ "seed": 120468
+ },
+ "train_options": {
+ "num_epoch": 5,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.05,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.999
+ },
+ "loss_options":{
+ "train": {"method": "eigvals"}
+ },
+ "save_freq": 1,
+ "display_freq": 10
+ },
+ "model_options": {
+ "nnsk": {
+ "onsite": {"method": "none"},
+ "hopping": {"method": "powerlaw", "rs":2.6, "w": 0.3},
+ "freeze": false
+ }
+ },
+ "data_options": {
+ "train": {
+ "root": "./dptb/tests/data/test_sktb/dataset/",
+ "prefix": "kpath_spk",
+ "get_eigenvalues": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/dptb/tests/test_negf_kmesh_sampling.py b/dptb/tests/test_negf_kmesh_sampling.py
deleted file mode 100644
index 30a6d29f..00000000
--- a/dptb/tests/test_negf_kmesh_sampling.py
+++ /dev/null
@@ -1,157 +0,0 @@
-from dptb.entrypoints import run
-import pytest
-import torch
-import numpy as np
-from dptb.utils.make_kpoints import kmesh_sampling_negf
-
-
-@pytest.fixture(scope='session', autouse=True)
-def root_directory(request):
- """
- :return:
- """
- return str(request.config.rootdir)
-
-
-def test_negf_ksampling(root_directory):
-
- #-------- 1D ksampling-----------
-
- ## even meshgrid
- meshgrid = [1,4,1]
- ### Gamma center
- is_gamma_center = True
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0. , 0. , 0. ],[0. , 0.25, 0. ],[0. , 0.5 , 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.5 , 0.25])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0., 0., 0.],[0., 0.25, 0.],[0., 0.5, 0.],[0., 0.75, 0.]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.25 ,0.25, 0.25])).max()<1e-5
-
- ### Monkhorst-Packing sampling
- is_gamma_center = False
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- print(kp)
- assert abs(kp-np.array([[0. , 0.125 , 0. ],[0. , 0.375, 0. ]])).max()<1e-5
- assert abs(wk-np.array([0.5, 0.5])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp-np.array([[ 0., -0.375, 0.],[ 0., -0.125, 0.],[ 0.,0.125,0.],[ 0.,0.375, 0.]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.25, 0.25, 0.25])).max()<1e-5
-
- ## odd meshgrid
- meshgrid = [1,5,1]
- ### Gamma center
- is_gamma_center = True
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0., 0., 0.],[0., 0.2, 0. ],[0., 0.4 , 0.]])).max()<1e-5
- assert abs(wk - np.array([0.2, 0.4, 0.4])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0., 0., 0.],[0., 0.2, 0. ],[0., 0.4 , 0.],[0., 0.6 , 0.],[0., 0.8 , 0.]])).max()<1e-5
- assert abs(wk - np.array([0.2, 0.2 ,0.2, 0.2, 0.2])).max()<1e-5
-
- ### Monkhorst-Packing sampling
- is_gamma_center = False
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp-np.array([[0. , 0.0 ,0 ],[0. , 0.2 ,0 ],[0., 0.4, 0 ]])).max()<1e-5
- assert abs(wk-np.array([0.2, 0.4, 0.4])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp-np.array([[ 0., -0.4, 0.],[ 0., -0.2, 0.],[ 0.,0.0,0.],[ 0.,0.2, 0.],[ 0.,0.4,0.]])).max()<1e-5
- assert abs(wk - np.array([0.2, 0.2, 0.2, 0.2, 0.2])).max()<1e-5
-
- #-------- 1D ksampling-----------
-
-
-
-
- #-------- 2D ksampling-----------
- ## even meshgrid
- meshgrid = [2,2,1]
- ### Gamma center
- is_gamma_center = True
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0. , 0. , 0. ],[0. , 0.5, 0. ],[0.5 , 0. , 0. ],[0.5 , 0.5 , 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.25 , 0.25, 0.25])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0. , 0. , 0. ],[0. , 0.5, 0. ],[0.5 , 0. , 0. ],[0.5 , 0.5 , 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.25 , 0.25, 0.25])).max()<1e-5
-
- ### Monkhorst-Packing sampling
- is_gamma_center = False
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- print(kp)
- assert abs(kp - np.array([[0.25, -0.25, 0. ],[0.25, 0.25, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.5,0.5])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[ -0.25, -0.25, 0. ],[ -0.25, 0.25, 0. ],[ 0.25, -0.25, 0. ],[ 0.25,0.25, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.25, 0.25, 0.25, 0.25])).max()<1e-5
-
- ## odd meshgrid
- meshgrid = [3,3,1]
- ### Gamma center
- is_gamma_center = True
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0. , 0. , 0. ],
- [0. , 0.33333333, 0. ],
- [0.33333333, 0. , 0. ],
- [0.33333333, 0.33333333, 0. ],
- [0.33333333, 0.66666667, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.11111111, 0.22222222, 0.22222222, 0.22222222, 0.22222222])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[0. , 0. , 0. ],
- [0. , 0.33333333, 0. ],
- [0. , 0.66666667, 0. ],
- [0.33333333, 0. , 0. ],
- [0.33333333, 0.33333333, 0. ],
- [0.33333333, 0.66666667, 0. ],
- [0.66666667, 0. , 0. ],
- [0.66666667, 0.33333333, 0. ],
- [0.66666667, 0.66666667, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.11111111, 0.11111111, 0.11111111, 0.11111111, 0.11111111,
- 0.11111111, 0.11111111, 0.11111111, 0.11111111])).max()<1e-5
-
- ### Monkhorst-Packing sampling
- is_gamma_center = False
- is_time_reversal = True
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- print(kp)
- assert abs(kp - np.array([[ 0. , 0. , 0. ],
- [ 0. , 0.33333333, 0. ],
- [ 0.33333333, -0.33333333, 0. ],
- [ 0.33333333, 0. , 0. ],
- [ 0.33333333, 0.33333333, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.11111111, 0.22222222, 0.22222222, 0.22222222, 0.22222222])).max()<1e-5
-
- is_time_reversal = False
- kp , wk = kmesh_sampling_negf(meshgrid, is_gamma_center, is_time_reversal)
- assert abs(kp - np.array([[-0.33333333, -0.33333333, 0. ],
- [-0.33333333, 0. , 0. ],
- [-0.33333333, 0.33333333, 0. ],
- [ 0. , -0.33333333, 0. ],
- [ 0. , 0. , 0. ],
- [ 0. , 0.33333333, 0. ],
- [ 0.33333333, -0.33333333, 0. ],
- [ 0.33333333, 0. , 0. ],
- [ 0.33333333, 0.33333333, 0. ]])).max()<1e-5
- assert abs(wk - np.array([0.11111111, 0.11111111, 0.11111111, 0.11111111, 0.11111111,
- 0.11111111, 0.11111111, 0.11111111, 0.11111111])).max()<1e-5
\ No newline at end of file
diff --git a/dptb/tests/test_nrl2json.py b/dptb/tests/test_nrl2json.py
deleted file mode 100644
index 7edf0ebb..00000000
--- a/dptb/tests/test_nrl2json.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import pytest
-from dptb.utils.read_NRL_tojson import read_nrl_file, nrl2dptb
-import json
-import numpy as np
-
-@pytest.fixture(scope='session', autouse=True)
-def root_directory(request):
- return str(request.config.rootdir)
-
-
-def test_nrl2json_v0(root_directory):
- nrl_file = root_directory + '/dptb/tests/data/nrl/Cu.par'
- ref_nrl_file = root_directory + '/dptb/tests/data/nrl/nrl_Cu_ckpt.json'
- input = root_directory + '/dptb/tests/data/nrl/input_Cu.json'
-
- with open(ref_nrl_file,'r') as f:
- ref_nrl_dict = json.load(f)
-
- NRL_data = read_nrl_file(nrl_file)
- input_dict, nrl_tb_dict = nrl2dptb(input, NRL_data)
-
- # check input_dict and ref_input_dict are the same, with the same keys and values.
- assert input_dict['common_options']['unit'] == 'Ry'
- assert abs(input_dict['common_options']['onsite_cutoff'] - 8.7314239798995) < 1E-8
- assert input_dict['common_options']['overlap'] == True
- assert input_dict['model_options']['skfunction']['skformula'] == "NRLv0"
- assert abs(input_dict['model_options']['skfunction']['sk_cutoff'] - 8.7314239798995) < 1E-8
- assert abs(input_dict['model_options']['skfunction']['sk_decay_w'] - 0.26459) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_cutoff'] - 8.7314239798995) < 1E-8
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_decay_w'] - 0.26459) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_lambda'] - 2.024780663957271) < 1E-8
-
- # check nrl_tb_dict and ref_nrl_dict are the same, with the same keys and values.
-
- assert set(list(nrl_tb_dict.keys())) == set(list(ref_nrl_dict.keys()))
- for ikey in nrl_tb_dict.keys():
- sub_dict = nrl_tb_dict[ikey]
- sub_ref_dict = ref_nrl_dict[ikey]
- assert set(list(sub_dict.keys())) == set(list(sub_ref_dict.keys()))
- for jkey in sub_dict.keys():
- assert (np.abs(np.asarray(sub_dict[jkey]) - np.asarray(sub_ref_dict[jkey])) < 1E-6).all()
-
-
-def test_nrl2json_v1_sp(root_directory):
- nrl_file = root_directory + '/dptb/tests/data/nrl/Si_sp.par'
- ref_nrl_file = root_directory + '/dptb/tests/data/nrl/nrl_Si_sp_ckpt.json'
- input = root_directory + '/dptb/tests/data/nrl/input_Si_sp.json'
-
- with open(ref_nrl_file,'r') as f:
- ref_nrl_dict = json.load(f)
-
- NRL_data = read_nrl_file(nrl_file)
- input_dict, nrl_tb_dict = nrl2dptb(input, NRL_data)
-
- # check input_dict and ref_input_dict are the same, with the same keys and values.
- assert input_dict['common_options']['unit'] == 'Ry'
- assert abs(input_dict['common_options']['onsite_cutoff'] - 6.6147151362875) < 1E-8
- assert input_dict['common_options']['overlap'] == True
- assert input_dict['model_options']['skfunction']['skformula'] == "NRLv1"
- assert abs(input_dict['model_options']['skfunction']['sk_cutoff'] - 6.6147151362875) < 1E-8
- assert abs(input_dict['model_options']['skfunction']['sk_decay_w'] - 0.2645886054515) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_cutoff'] - 6.6147151362875) < 1E-8
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_decay_w'] - 0.2645886054515) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_lambda'] - 1.517042837140912) < 1E-8
-
- # check nrl_tb_dict and ref_nrl_dict are the same, with the same keys and values.
-
- assert set(list(nrl_tb_dict.keys())) == set(list(ref_nrl_dict.keys()))
- for ikey in nrl_tb_dict.keys():
- sub_dict = nrl_tb_dict[ikey]
- sub_ref_dict = ref_nrl_dict[ikey]
- assert set(list(sub_dict.keys())) == set(list(sub_ref_dict.keys()))
- for jkey in sub_dict.keys():
- assert (np.abs(np.asarray(sub_dict[jkey]) - np.asarray(sub_ref_dict[jkey])) < 1E-6).all()
-
-
-
-def test_nrl2json_v1_spd(root_directory):
- nrl_file = root_directory + '/dptb/tests/data/nrl/Si_spd.par'
- ref_nrl_file = root_directory + '/dptb/tests/data/nrl/nrl_Si_spd_ckpt.json'
- input = root_directory + '/dptb/tests/data/nrl/input_Si_spd.json'
-
- with open(ref_nrl_file,'r') as f:
- ref_nrl_dict = json.load(f)
-
- NRL_data = read_nrl_file(nrl_file)
- input_dict, nrl_tb_dict = nrl2dptb(input, NRL_data)
-
- # check input_dict and ref_input_dict are the same, with the same keys and values.
- assert input_dict['common_options']['unit'] == 'Ry'
- assert abs(input_dict['common_options']['onsite_cutoff'] - 6.6147151362875) < 1E-8
- assert input_dict['common_options']['overlap'] == True
- assert input_dict['model_options']['skfunction']['skformula'] == "NRLv1"
- assert abs(input_dict['model_options']['skfunction']['sk_cutoff'] - 6.6147151362875) < 1E-8
- assert abs(input_dict['model_options']['skfunction']['sk_decay_w'] - 0.2645886054515) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_cutoff'] - 6.6147151362875) < 1E-8
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_decay_w'] - 0.2645886054515) < 1E-4
- assert abs(input_dict['model_options']['onsitefuncion']['onsite_func_lambda'] - 1.5269575694188455) < 1E-8
-
- # check nrl_tb_dict and ref_nrl_dict are the same, with the same keys and values.
-
- assert set(list(nrl_tb_dict.keys())) == set(list(ref_nrl_dict.keys()))
- for ikey in nrl_tb_dict.keys():
- sub_dict = nrl_tb_dict[ikey]
- sub_ref_dict = ref_nrl_dict[ikey]
- assert set(list(sub_dict.keys())) == set(list(sub_ref_dict.keys()))
- for jkey in sub_dict.keys():
- assert (np.abs(np.asarray(sub_dict[jkey]) - np.asarray(sub_ref_dict[jkey])) < 1E-6).all()
\ No newline at end of file
diff --git a/dptb/tests/test_sktb.py b/dptb/tests/test_sktb.py
new file mode 100644
index 00000000..45c8547f
--- /dev/null
+++ b/dptb/tests/test_sktb.py
@@ -0,0 +1,49 @@
+from dptb.entrypoints import train
+import pytest
+import torch
+import numpy as np
+
+@pytest.fixture(scope='session', autouse=True)
+def root_directory(request):
+ return str(request.config.rootdir)
+
+def test_nnsk_valence():
+ INPUT_file = "./dptb/tests/data/test_sktb/input/input_valence.json"
+ output = "./dptb/tests/data/test_sktb/output"
+
+ train(INPUT=INPUT_file, init_model=None, restart=None, train_soc=False,\
+ output=output+"/test_valence", log_level=5, log_path=output+"/test_valence.log")
+
+def test_nnsk_strain_polar():
+ INPUT_file = "./dptb/tests/data/test_sktb/input/input_strain_polar.json"
+ output = "./dptb/tests/data/test_sktb/output"
+ init_model = "./dptb/tests/data/test_sktb/output/test_valence/checkpoint/nnsk.iter6.pth"
+
+ train(INPUT=INPUT_file, init_model=init_model, restart=None, train_soc=False,\
+ output=output+"/test_strain_polar", log_level=5, log_path=output+"/test_strain_polar.log")
+
+def test_nnsk_push():
+ INPUT_file_rs = "./dptb/tests/data/test_sktb/input/input_push_rs.json"
+ INPUT_file_w = "./dptb/tests/data/test_sktb/input/input_push_w.json"
+ output = "./dptb/tests/data/test_sktb/output"
+ init_model = "./dptb/tests/data/test_sktb/output/test_strain_polar/checkpoint/nnsk.iter6.pth"
+
+ train(INPUT=INPUT_file_rs, init_model=init_model, restart=None, train_soc=False,\
+ output=output+"/test_push_rs", log_level=5, log_path=output+"/test_push_rs.log")
+ train(INPUT=INPUT_file_w, init_model=init_model, restart=None, train_soc=False,\
+ output=output+"/test_push_w", log_level=5, log_path=output+"/test_push_w.log")
+
+ model_rs = torch.load("./dptb/tests/data/test_sktb/output/test_push_rs/checkpoint/nnsk.iter11.pth")
+ model_w = torch.load("./dptb/tests/data/test_sktb/output/test_push_w/checkpoint/nnsk.iter11.pth")
+ # test push limits
+ # 10 epoch, 0.01 step, 1 period -> 0.05 added.
+ assert np.isclose(model_rs["config"]["model_options"]["nnsk"]["hopping"]["rs"], 2.65)
+ assert np.isclose(model_w["config"]["model_options"]["nnsk"]["hopping"]["w"], 0.35)
+
+def test_md():
+ INPUT_file = "./dptb/tests/data/test_sktb/input/input_md.json"
+ output = "./dptb/tests/data/test_sktb/output"
+ init_model = "./dptb/tests/data/test_sktb/output/test_push_w/checkpoint/nnsk.iter11.pth"
+
+ train(INPUT=INPUT_file, init_model=init_model, restart=None, train_soc=False,\
+ output=output+"/test_md", log_level=5, log_path=output+"/test_md.log")
\ No newline at end of file
diff --git a/dptb/tests/test_tbtrans_init.py b/dptb/tests/test_tbtrans_init.py
deleted file mode 100644
index b45c979a..00000000
--- a/dptb/tests/test_tbtrans_init.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import pytest
-from dptb.nnops.apihost import NNSKHost
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.postprocess.tbtrans_init import TBTransInputSet
-from dptb.utils.tools import j_loader
-import numpy as np
-
-@pytest.fixture(scope='session', autouse=True)
-def root_directory(request):
- return str(request.config.rootdir)
-
-
-def test_tbtrans_init(root_directory):
-
- # check whether sisl is installed: if not, skip this test
- try:
- import sisl
- except:
- pytest.skip('sisl is not installed which is necessary for TBtrans Input Generation. Therefore, skipping test_tbtrans_init.')
-
- model_ckpt = f'{root_directory}/dptb/tests/data/test_tbtrans/best_nnsk_b3.600_c3.600_w0.300.json'
- config = f'{root_directory}/dptb/tests/data/test_tbtrans/negf_tbtrans.json'
- apihost = NNSKHost(checkpoint=model_ckpt, config=config)
- apihost.register_plugin(InitSKModel())
- apihost.build()
- apiHrk = NN2HRK(apihost=apihost, mode='nnsk')
-
- run_opt = {
- "run_sk": True,
- "init_model":model_ckpt,
- "results_path":f'{root_directory}/dptb/tests/data/test_tbtrans/',
- "structure":f'{root_directory}/dptb/tests/data/test_tbtrans/test_hBN_zigzag_struct.xyz',
- "log_path": '/data/DeepTB/dptb_Zjj/DeePTB/dptb/tests/data/test_tbtrans/output',
- "log_level": 5,
- "use_correction":False
- }
-
- jdata = j_loader(config)
- jdata = jdata['task_options']
- tbtrans_hBN = TBTransInputSet(apiHrk=apiHrk,run_opt=run_opt, jdata=jdata)
-
- # check _orbitals_name_get
- element_orbital_name = tbtrans_hBN._orbitals_name_get(['2s', '2p'])
- assert element_orbital_name == ['2s', '2py', '2pz', '2px']
- element_orbital_name = tbtrans_hBN._orbitals_name_get(['3s', '3p', 'd*'])
- assert element_orbital_name == ['3s', '3py', '3pz', '3px', 'dxy*', 'dyz*', 'dz2*', 'dxz*', 'dx2-y2*']
-
-
-
- tbtrans_hBN.hamil_get_write(write_nc=False)
- assert (tbtrans_hBN.allbonds_all[0].detach().numpy()-np.array([5, 0, 5, 0, 0, 0, 0])).max()<1e-5
- assert (tbtrans_hBN.allbonds_all[50].detach().numpy()-np.array([ 5, 2, 5, 18, 0, 0, -1])).max()<1e-5
- assert (tbtrans_hBN.hamil_block_all[0].detach().numpy()- np.array([[-0.73303634, 0. , 0. , 0. ],
- [ 0. , 0.04233637, 0. , 0. ],
- [ 0. , 0. , 0.04233636, 0. ],
- [ 0. , 0. , 0. , -0.27156556]])).max()<1e-5
- assert (tbtrans_hBN.hamil_block_all[50].detach().numpy()-np.array([[-0.03164609, -0. , 0.02028139, -0. ],
- [ 0. , 0.00330366, 0. , 0. ],
- [-0.02028139, 0. , -0.05393751, 0. ],
- [ 0. , 0. , 0. , 0.00330366]])).max()<1e-5
- assert (tbtrans_hBN.allbonds_lead_L[0].detach().numpy()-np.array([5, 0, 5, 0, 0, 0, 0])).max()<1e-5
- assert (tbtrans_hBN.allbonds_lead_L[50].detach().numpy()-np.array([5, 4, 7, 7, 0, 0, 0])).max()<1e-5
- assert (tbtrans_hBN.hamil_block_lead_L[0].detach().numpy()-np.array([[-0.73303634, 0. , 0. , 0. ],
- [ 0. , 0.04233637, 0. , 0. ],
- [ 0. , 0. , 0.04233636, 0. ],
- [ 0. , 0. , 0. , -0.27156556]])).max()<1e-5
- assert (tbtrans_hBN.hamil_block_lead_L[50].detach().numpy()-np.array([[ 0.1145315 , -0.06116847, 0.10594689, 0. ],
- [ 0.15539739, -0.04634972, 0.22751862, 0. ],
- [-0.26915616, 0.22751862, -0.30906558, 0. ],
- [-0. , 0. , 0. , 0.08500822]])).max()<1e-5
-
-
- # tbtrans_hBN.hamil_write()
- # check the hamiltonian through Hk at Gamma and M
- H_lead = tbtrans_hBN.H_lead_L
- G_eigs = sisl.BandStructure(H_lead, [[0., 0.,0.]], 1, ["G"])
- M_eigs = sisl.BandStructure(H_lead, [[0, 0.5 ,0 ]], 1, ["M"])
- Ef = -9.874358177185059
- G_eigs = G_eigs.apply.array.eigh() -Ef
- M_eigs = M_eigs.apply.array.eigh() -Ef
-
- G_eigs_right = np.array([[-19.95431228, -17.10836511, -17.10836511, -16.91249093, -11.20658215,
- -10.01096331, -10.01096331, -8.11484357, -8.11484357, -7.60482165,
- -6.65543971, -3.79243033, -3.79243032, -3.22893608, -3.22893608,
- -3.17565711, 3.18687914, 3.2401581, 3.2401581, 6.4529848,
- 7.70578579, 7.91102607 , 10.91061078 , 10.91061078 , 23.6481713,
- 23.6481713, 28.30797724 , 28.30797738 , 28.65762375 , 30.78500847,
- 33.2545355 , 33.2545355 ]])
-
- M_eigs_right = np.array([[-18.69719147, -18.69719147, -16.91249065, -16.91249065, -11.20658214,
- -11.20658214, -7.4476675, -7.4476675 , -6.65543987 ,-6.65543987,
- -5.79288269, -5.79288269, -5.21972335 , -5.21972335 , -3.17565711,
- -3.17565711, 3.18687914, 3.18687914 , 5.84897577 , 5.84897577,
- 7.74721734, 7.74721734, 7.91102615 , 7.91102615 , 28.12953979,
- 28.12953979, 28.65762339, 28.65762339, 29.54228118, 29.54228118,
- 30.78500872, 30.78500872]])
-
-
- assert (G_eigs[0]-G_eigs_right[0]).max()<1e-5
- assert (M_eigs[0]-M_eigs_right[0]).max()<1e-5
-
-
-
-
diff --git a/dptb/utils/__init__.py b/dptb/utils/__init__.py
index e69de29b..fe2f1213 100644
--- a/dptb/utils/__init__.py
+++ b/dptb/utils/__init__.py
@@ -0,0 +1 @@
+from dptb.utils.auto_init import *
\ No newline at end of file
diff --git a/dptb/utils/argcheck.py b/dptb/utils/argcheck.py
index 60020aed..36336959 100644
--- a/dptb/utils/argcheck.py
+++ b/dptb/utils/argcheck.py
@@ -10,58 +10,29 @@
'dptb-hopping_net_neuron', 'dptb-env_net_neuron', 'dptb-soc_net_neuron', 'dptb-onsite_net_neuron', 'dptb-axis_neuron', 'skfunction-skformula', 'sknetwork-sk_onsite_nhidden',
'sknetwork-sk_hop_nhidden']
-
-def init_model():
- doc_path = "The model checkpoint path"
- doc_interpolate = r"Use linear interpolation of hoppings between single atom types to init the inter type atom's hopping; Default: `False`"
-
- args = [
- Argument("path", [list, str, None], optional = True, default=None, doc = doc_path),
- Argument("interpolate", bool, optional = True, default=False, doc = doc_interpolate)
- ]
- doc_init_model = ""
- return Argument("init_model", dict, optional = True, default={}, sub_fields=args, doc = doc_init_model)
-
def common_options():
doc_device = "The device to run the calculation, choose among `cpu` and `cuda[:int]`, Default: `cpu`"
doc_dtype = "The digital number's precison, choose among: \n\n\
- `float32`: indicating torch.float32\n\n\
- `float64`: indicating torch.float64\n\n\
Default: `float32`\n\n"
- doc_onsitemode = r"The onsite correction mode, the onsite energy is expressed as the energy of isolated atoms plus the model correction, the correction mode are:\n\n\
- - `strain`: The strain mode correct the onsite matrix densly by $$H_{i,i}^{lm,l^\prime m^\prime} = \epsilon_l^0 \delta_{ll^\prime}\delta_{mm^\prime} + \sum_p \sum_{\zeta} \Big[ \mathcal{U}_{\zeta}(\hat{\br}_{ip}) \ \epsilon_{ll^\prime \zeta} \Big]_{mm^\prime}$$ which is also parameterized as a set of Slater-Koster like integrals.\n\n\
- - `uniform`: The correction is a energy shift respect of orbital of each atom. Which is formally written as: \n\n\
- $$H_{i,i}^{lm,l^\prime m^\prime} = (\epsilon_l^0+\epsilon_l^\prime) \delta_{ll^\prime}\delta_{mm^\prime}$$ Where $\epsilon_l^0$ is the isolated energy level from the DeePTB onsite database, and $\epsilon_l^\prime$ is the parameters to fit. E.p. \n\n\
- - `split`: (not recommanded) The split onsite mode correct onsite hamiltonian with a magnetic quantum number dependent form, which violate the rotation equivariace, but some times can be effective. The formula is: \
- $$H_{i,i}^{lm,l^\prime m^\prime} = (\epsilon_l^0+\epsilon_{lm}^\prime) \delta_{ll^\prime}\delta_{mm^\prime}$$ \n\n\
- Default: `none`"
- doc_onsite_cutoff = "The cutoff-range considered when using strain mode correction. Out of which the atom are assume to have no effect on current atom's onsite energy."
- doc_bond_cutoff = "The cutoff-range of bond hoppings, beyond which it assume the atom pairs have 0 hopping integrals."
- doc_env_cutoff = "The cutoff-range of DeePTB environmental correction, recommand range is: (0.5*bond_cutoff, bond_cutoff)"
- doc_sk_file_path = ""
- doc_proj_atom_neles = "Number of electron considered atoms of the system."
- doc_proj_atom_anglr_m = "The atomic orbitals used to construct the basis. E.p. {'A':'2s','2p','s*','B':'3s','3p' }"
- doc_atomtype = "The list of atom type consist in the system."
- doc_time_symm = "Determine whether time symmetry is conserved, if set to be True, the eigenvalues on -k and k point is considered equal. Default: `True`"
- doc_soc = "Determine whether soc effect is modeled. If True, the soc network setting in model options need to be setted. Default: `False`"
- doc_unit = "Determine the unit of Tight-Binding parameters learned in DeePTB. Can be `eV`, `Hartree` or `Rothberg`. It will not affect the eigenvalues output form DeePTB, which is always in the unit of eV. Default: `Hartree`"
- doc_overlap = r"Whether to use overlap matrix to define the SK like integrals. Default: False"
+
+ doc_seed = "The random seed used to initialize the parameters and determine the shuffling order of datasets. Default: `3982377700`"
+ #doc_onsite_cutoff = "The cutoff-range considered when using strain mode correction. Out of which the atom are assume to have no effect on current atom's onsite energy."
+ #doc_bond_cutoff = "The cutoff-range of bond hoppings, beyond which it assume the atom pairs have 0 hopping integrals."
+ #doc_env_cutoff = "The cutoff-range of DeePTB environmental correction, recommand range is: (0.5*bond_cutoff, bond_cutoff)"
+ doc_basis = "The atomic orbitals used to construct the basis. E.p. {'A':'2s','2p','s*','B':'3s','3p' }"
+ doc_overlap = ""
args = [
- Argument("onsite_cutoff", float, optional = False, doc = doc_onsite_cutoff),
- Argument("bond_cutoff", float, optional = False, doc = doc_bond_cutoff),
- Argument("env_cutoff", float, optional = False, doc = doc_env_cutoff),
- Argument("atomtype", list, optional = False, doc = doc_atomtype),
- Argument("proj_atom_neles", dict, optional = False, doc = doc_proj_atom_neles),
- Argument("proj_atom_anglr_m", dict, optional = False, doc = doc_proj_atom_anglr_m),
+ #Argument("onsite_cutoff", float, optional = True, doc = doc_onsite_cutoff),
+ #Argument("bond_cutoff", float, optional = False, doc = doc_bond_cutoff),
+ #Argument("env_cutoff", float, optional = True, doc = doc_env_cutoff),
+ Argument("basis", dict, optional=False, doc=doc_basis),
+ Argument("seed", int, optional=True, default=3982377700, doc=doc_seed),
+ Argument("overlap", bool, optional=True, default=False, doc=doc_overlap),
Argument("device", str, optional = True, default="cpu", doc = doc_device),
Argument("dtype", str, optional = True, default="float32", doc = doc_dtype),
- Argument("onsitemode", str, optional = True, default = "none", doc = doc_onsitemode),
- Argument("sk_file_path", str, optional = True, default="./", doc = doc_sk_file_path),
- Argument("time_symm", bool, optional = True, default=True, doc = doc_time_symm),
- Argument("soc", bool, optional=True, default=False, doc=doc_soc),
- Argument("overlap", bool, optional=True, default=False, doc=doc_overlap),
- Argument("unit", str, optional=True, default="Hartree", doc=doc_unit)
]
doc_common_options = ""
@@ -71,7 +42,6 @@ def common_options():
def train_options():
doc_num_epoch = "Total number of training epochs. It is worth noted, if the model is reloaded with `-r` or `--restart` option, epoch which have been trained will counted from the time that the checkpoint is saved."
- doc_seed = "The random seed used to initialize the parameters and determine the shuffling order of datasets. Default: `3982377700`"
doc_save_freq = "Frequency, or every how many iteration to saved the current model into checkpoints, The name of checkpoint is formulated as `latest|best_dptb|nnsk_b_c_w`. Default: `10`"
doc_validation_freq = "Frequency or every how many iteration to do model validation on validation datasets. Default: `10`"
doc_display_freq = "Frequency, or every how many iteration to display the training log to screem. Default: `1`"
@@ -83,20 +53,38 @@ def train_options():
- `LBFGS`: [On the limited memory BFGS method for large scale optimization.](http://users.iems.northwestern.edu/~nocedal/PDFfiles/limited-memory.pdf) \n\n\
"
doc_lr_scheduler = "The learning rate scheduler tools settings, the lr scheduler is used to scales down the learning rate during the training process. Proper setting can make the training more stable and efficient. The supported lr schedular includes: `Exponential Decaying (exp)`, `Linear multiplication (linear)`"
-
+ doc_batch_size = ""
+
args = [
Argument("num_epoch", int, optional=False, doc=doc_num_epoch),
- Argument("seed", int, optional=True, default=3982377700, doc=doc_seed),
+ Argument("batch_size", int, optional=True, default=1, doc=doc_batch_size),
+ Argument("ref_batch_size", int, optional=True, default=1, doc=doc_batch_size),
+ Argument("val_batch_size", int, optional=True, default=1, doc=doc_batch_size),
Argument("optimizer", dict, sub_fields=[], optional=True, default={}, sub_variants=[optimizer()], doc = doc_optimizer),
Argument("lr_scheduler", dict, sub_fields=[], optional=True, default={}, sub_variants=[lr_scheduler()], doc = doc_lr_scheduler),
Argument("save_freq", int, optional=True, default=10, doc=doc_save_freq),
Argument("validation_freq", int, optional=True, default=10, doc=doc_validation_freq),
- Argument("display_freq", int, optional=True, default=1, doc=doc_display_freq)
+ Argument("display_freq", int, optional=True, default=1, doc=doc_display_freq),
+ loss_options()
]
doc_train_options = "Options that defines the training behaviour of DeePTB."
- return Argument("train_options", dict, sub_fields=args, sub_variants=[], optional=False, doc=doc_train_options)
+ return Argument("train_options", dict, sub_fields=args, sub_variants=[], optional=True, doc=doc_train_options)
+
+def test_options():
+ doc_display_freq = "Frequency, or every how many iteration to display the training log to screem. Default: `1`"
+ doc_batch_size = ""
+
+ args = [
+ Argument("batch_size", int, optional=True, default=1, doc=doc_batch_size),
+ Argument("display_freq", int, optional=True, default=1, doc=doc_display_freq),
+ loss_options()
+ ]
+
+ doc_test_options = "Options that defines the testing behaviour of DeePTB."
+
+ return Argument("test_options", dict, sub_fields=args, sub_variants=[], optional=False, doc=doc_test_options)
def Adam():
@@ -157,24 +145,57 @@ def LinearLR():
Argument("total_iters", int, optional=True, default=5, doc=doc_total_iters)
]
+def ReduceOnPlateau():
+ doc_mode = "One of min, max. In min mode, lr will be reduced when the quantity monitored has stopped decreasing; \
+ in max mode it will be reduced when the quantity monitored has stopped increasing. Default: 'min'."
+ doc_factor = "Factor by which the learning rate will be reduced. new_lr = lr * factor. Default: 0.1."
+ doc_patience = "Number of epochs with no improvement after which learning rate will be reduced. For example, \
+ if patience = 2, then we will ignore the first 2 epochs with no improvement, \
+ and will only decrease the LR after the 3rd epoch if the loss still hasn't improved then. Default: 10."
+ doc_threshold = "Threshold for measuring the new optimum, to only focus on significant changes. Default: 1e-4."
+ doc_threshold_mode = "One of rel, abs. In rel mode, dynamic_threshold = best * ( 1 + threshold ) in 'max' mode or \
+ best * ( 1 - threshold ) in min mode. In abs mode, \
+ dynamic_threshold = best + threshold in max mode or best - threshold in min mode. Default: 'rel'."
+ doc_cooldown = "Number of epochs to wait before resuming normal operation after lr has been reduced. Default: 0."
+ doc_min_lr = "A scalar or a list of scalars. \
+ A lower bound on the learning rate of all param groups or each group respectively. Default: 0."
+ doc_eps = "Minimal decay applied to lr. \
+ If the difference between new and old lr is smaller than eps, the update is ignored. Default: 1e-8."
+
+ return [
+ Argument("mode", str, optional=True, default="min", doc=doc_mode),
+ Argument("factor", float, optional=True, default=0.1, doc=doc_factor),
+ Argument("patience", int, optional=True, default=10, doc=doc_patience),
+ Argument("threshold", float, optional=True, default=1e-4, doc=doc_threshold),
+ Argument("threshold_mode", str, optional=True, default="rel", doc=doc_threshold_mode),
+ Argument("cooldown", int, optional=True, default=0, doc=doc_cooldown),
+ Argument("min_lr", [float, list], optional=True, default=0, doc=doc_min_lr),
+ Argument("eps", float, optional=True, default=1e-8, doc=doc_eps),
+ ]
+
+
def lr_scheduler():
doc_type = "select type of lr_scheduler, support type includes `exp`, `linear`"
return Variant("type", [
Argument("exp", dict, ExponentialLR()),
- Argument("linear", dict, LinearLR())
+ Argument("linear", dict, LinearLR()),
+ Argument("rop", dict, ReduceOnPlateau(), doc="rop: reduce on plateau")
],optional=True, default_tag="exp", doc=doc_type)
def train_data_sub():
- doc_batch_size = "number of configurations used to update the model parameters in a step of optmization."
- doc_path = "the path of dataset folders"
- doc_prefix = "the prefix of dataset folder's name. The dataset is recommended to named as ., data with the same prefix will be loaded as the datasets."
+ doc_root = "This is where the dataset stores data files."
+ doc_prefix = "The prefix of the folders under root, which will be loaded in dataset."
+ doc_ham = "Choose whether the Hamiltonian blocks (and overlap blocks, if provided) are loaded when building dataset."
+ doc_eig = "Choose whether the eigenvalues and k-points are loaded when building dataset."
args = [
- Argument("batch_size", int, optional=False, doc=doc_batch_size),
- Argument("path", str, optional=False, doc=doc_path),
- Argument("prefix", str, optional=False, doc=doc_prefix)
+ Argument("type", str, optional=True, default="DefaultDataset", doc="The type of dataset."),
+ Argument("root", str, optional=False, doc=doc_root),
+ Argument("prefix", str, optional=True, default=None, doc=doc_prefix),
+ Argument("get_Hamiltonian", bool, optional=True, default=False, doc=doc_ham),
+ Argument("get_eigenvalues", bool, optional=True, default=False, doc=doc_eig)
]
doc_train = ""
@@ -182,44 +203,53 @@ def train_data_sub():
return Argument("train", dict, optional=False, sub_fields=args, sub_variants=[], doc=doc_train)
def validation_data_sub():
- doc_batch_size = "number of configurations used to update the model parameters in a step of optmization."
- doc_path = "the path of dataset folders"
- doc_prefix = "the prefix of dataset folder's name. The dataset is recommended to named as ., data with the same prefix will be loaded as the datasets."
-
+ doc_root = "This is where the dataset stores data files."
+ doc_prefix = "The prefix of the folders under root, which will be loaded in dataset."
+ doc_ham = "Choose whether the Hamiltonian blocks (and overlap blocks, if provided) are loaded when building dataset."
+ doc_eig = "Choose whether the eigenvalues and k-points are loaded when building dataset."
+
args = [
- Argument("batch_size", int, optional=False, doc=doc_batch_size),
- Argument("path", str, optional=False, doc=doc_path),
- Argument("prefix", str, optional=False, doc=doc_prefix)
+ Argument("type", str, optional=True, default="DefaultDataset", doc="The type of dataset."),
+ Argument("root", str, optional=False, doc=doc_root),
+ Argument("prefix", str, optional=True, default=None, doc=doc_prefix),
+ Argument("get_Hamiltonian", bool, optional=True, default=False, doc=doc_ham),
+ Argument("get_eigenvalues", bool, optional=True, default=False, doc=doc_eig)
]
doc_validation = ""
- return Argument("validation", dict, optional=False, sub_fields=args, sub_variants=[], doc=doc_validation)
+ return Argument("validation", dict, optional=True, sub_fields=args, sub_variants=[], doc=doc_validation)
def reference_data_sub():
- doc_batch_size = "number of configurations used to update the model parameters in a step of optmization."
- doc_path = "the path of dataset folders"
- doc_prefix = "the prefix of dataset folder's name. The dataset is recommended to named as ., data with the same prefix will be loaded as the datasets."
+ doc_root = "This is where the dataset stores data files."
+ doc_prefix = "The prefix of the folders under root, which will be loaded in dataset."
+ doc_ham = "Choose whether the Hamiltonian blocks (and overlap blocks, if provided) are loaded when building dataset."
+ doc_eig = "Choose whether the eigenvalues and k-points are loaded when building dataset."
args = [
- Argument("batch_size", int, optional=False, doc=doc_batch_size),
- Argument("path", str, optional=False, doc=doc_path),
- Argument("prefix", str, optional=False, doc=doc_prefix)
+ Argument("type", str, optional=True, default="DefaultDataset", doc="The type of dataset."),
+ Argument("root", str, optional=False, doc=doc_root),
+ Argument("prefix", str, optional=True, default=None, doc=doc_prefix),
+ Argument("get_Hamiltonian", bool, optional=True, default=False, doc=doc_ham),
+ Argument("get_eigenvalues", bool, optional=True, default=False, doc=doc_eig)
]
doc_reference = ""
- return Argument("reference", dict, optional=False, sub_fields=args, sub_variants=[], doc=doc_reference)
+ return Argument("reference", dict, optional=True, sub_fields=args, sub_variants=[], doc=doc_reference)
def test_data_sub():
- doc_batch_size = "number of configurations used to update the model parameters in a step of optmization."
- doc_path = "the path of dataset folders"
- doc_prefix = "the prefix of dataset folder's name. The dataset is recommended to named as ., data with the same prefix will be loaded as the datasets."
+ doc_root = "This is where the dataset stores data files."
+ doc_prefix = "The prefix of the folders under root, which will be loaded in dataset."
+ doc_ham = "Choose whether the Hamiltonian blocks (and overlap blocks, if provided) are loaded when building dataset."
+ doc_eig = "Choose whether the eigenvalues and k-points are loaded when building dataset."
args = [
- Argument("batch_size", int, optional=False, doc=doc_batch_size),
- Argument("path", str, optional=False, doc=doc_path),
- Argument("prefix", str, optional=False, doc=doc_prefix)
+ Argument("type", str, optional=True, default="DefaultDataset", doc="The type of dataset."),
+ Argument("root", str, optional=False, doc=doc_root),
+ Argument("prefix", str, optional=True, default=None, doc=doc_prefix),
+ Argument("get_Hamiltonian", bool, optional=True, default=False, doc=doc_ham),
+ Argument("get_eigenvalues", bool, optional=True, default=False, doc=doc_eig)
]
doc_reference = ""
@@ -230,8 +260,7 @@ def test_data_sub():
def data_options():
doc_use_reference = "Whether to use a reference dataset that jointly train the model. It acting as a constraint or normalization to make sure the model won't deviate too much from the reference data."
- args = [Argument("use_reference", bool, optional=False, doc=doc_use_reference),
- Argument("use_wannier",bool, optional=True, default=False, doc="Whether to use wannier90_hr.dat to construct the wannier basis for the reference data. Default: False"),
+ args = [
train_data_sub(),
validation_data_sub(),
reference_data_sub()
@@ -251,162 +280,418 @@ def test_data_options():
return Argument("data_options", dict, sub_fields=args, sub_variants=[], optional=False, doc=doc_test_data_options)
+# def dptb():
+# doc_soc_env = "button that allow environmental correction for soc parameters, used only when soc is open, Default: False"
+# doc_axis_neuron = "The axis_neuron specifies the size of the submatrix of the embedding matrix, the axis matrix as explained in the [DeepPot-SE paper](https://arxiv.org/abs/1805.09003)."
+# doc_onsite_net_neuron = r"The number of hidden neurons in the network for onsites $\langle i|H|i\rangle$ of `dptb` model. Default: `[128, 128, 256, 256]`"
+# doc_env_net_neuron = "The number of hidden neurons in the environment embedding network of `dptb` model. Default: `[128, 128, 256, 256]`"
+# doc_hopping_net_neuron = r"The number of hidden neurons in the network for hoppings $\langle i|H|j\rangle$ of `dptb` model. Default: `[128, 128, 256, 256]`"
+# doc_onsite_net_activation = "The activation function for onsite networks. Default: `tanh`"
+# doc_env_net_activation = "The activation function for environment embedding networks. Default: `tanh`"
+# doc_hopping_net_activation = "The activation function for hopping networks. Default: `tanh`"
+# doc_soc_net_activation = "The activation function for soc networks. Default: `tanh`"
+# doc_soc_net_neuron = r"The number of hidden neurons in the network for soc $\lambda$ of `dptb` model. Default: `[128, 128, 256, 256]`"
+# doc_soc_net_type = "The network type for soc, the value can be:\n\n\
+# - `res`: for feedforward Network with residual connections, for more information about residual network, we refer to [Deep Residual Learning for Image Recognition](https://openaccess.thecvf.com/content_cvpr_2016/papers/He_Deep_Residual_Learning_CVPR_2016_paper.pdf). \n\n\
+# - `ffn`: for feedforward Network."
+# doc_onsite_net_type = "The network type for onsites."
+# doc_env_net_type = "The network type for environment embeddings."
+# doc_hopping_net_type = "The network type for hoppings."
+# doc_if_batch_normalized = "Whether to use batch normalization after each layer in neural network. The batch normalization normalize the itermidiate values in neural network with the mean and variance estimated in the batch dimension. The batch here means the batch of onsite or hopping embeddings or position vectors that processed by neural network at one time computation, which is different from the batch defined in `data_options`. Default: False."
+
+# args = [
+# Argument("soc_env", bool, optional=True, default=False, doc=doc_soc_env),
+# Argument("axis_neuron", int, optional=True, default=10, doc=doc_axis_neuron),
+# Argument("onsite_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_onsite_net_neuron),
+# Argument("soc_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_soc_net_neuron),
+# Argument("env_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_env_net_neuron),
+# Argument("hopping_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_hopping_net_neuron),
+# Argument("onsite_net_activation", str, optional=True, default="tanh", doc=doc_onsite_net_activation),
+# Argument("env_net_activation", str, optional=True, default="tanh", doc=doc_env_net_activation),
+# Argument("hopping_net_activation", str, optional=True, default="tanh", doc=doc_hopping_net_activation),
+# Argument("soc_net_activation", str, optional=True, default="tanh", doc=doc_soc_net_activation),
+# Argument("onsite_net_type", str, optional=True, default="res", doc=doc_onsite_net_type),
+# Argument("env_net_type", str, optional=True, default="res", doc=doc_env_net_type),
+# Argument("hopping_net_type", str, optional=True, default="res", doc=doc_hopping_net_type),
+# Argument("soc_net_type", str, optional=True, default="res", doc=doc_soc_net_type),
+# Argument("if_batch_normalized", bool, optional=True, default=False, doc=doc_if_batch_normalized)
+# ]
+
+# doc_dptb = "The parameters for `dptb` model, which maps the environmental information to Tight-Binding parameters."
+
+# return Argument("dptb", dict, optional=True, sub_fields=args, sub_variants=[], default={}, doc=doc_dptb)
+
+
+def embedding():
+ doc_method = ""
-def sknetwork():
- doc_sk_hop_nhidden = "the size of nnsk's hidden neuron for each hopping parameter."
- doc_sk_onsite_nhidden = "the size of nnsk's hidden neuron for each onsite parameter."
- doc_sk_soc_nhidden = "the size of nnsk's hidden neuron for each soc parameters"
+ return Variant("method", [
+ Argument("se2", dict, se2()),
+ Argument("baseline", dict, baseline()),
+ Argument("deeph-e3", dict, deephe3()),
+ Argument("e3baseline_local", dict, e3baseline()),
+ Argument("e3baseline_local_wnode", dict, e3baseline()),
+ Argument("e3baseline_nonlocal", dict, e3baseline()),
+ ],optional=True, default_tag="se2", doc=doc_method)
+
+def se2():
+
+ doc_rs = ""
+ doc_rc = ""
+ doc_n_axis = ""
+ doc_radial_net = ""
+
+ doc_neurons = ""
+ doc_activation = ""
+ doc_if_batch_normalized = ""
+
+ radial_net = [
+ Argument("neurons", list, optional=False, doc=doc_neurons),
+ Argument("activation", str, optional=True, default="tanh", doc=doc_activation),
+ Argument("if_batch_normalized", bool, optional=True, default=False, doc=doc_if_batch_normalized),
+ ]
- args = [
- Argument("sk_hop_nhidden", int, optional=False, doc=doc_sk_hop_nhidden),
- Argument("sk_onsite_nhidden", int, optional=False, doc=doc_sk_onsite_nhidden),
- Argument("sk_soc_nhidden", [int, None], optional=True, default=None, doc=doc_sk_soc_nhidden)
+ return [
+ Argument("rs", [float, int], optional=False, doc=doc_rs),
+ Argument("rc", [float, int], optional=False, doc=doc_rc),
+ Argument("radial_net", dict, sub_fields=radial_net, optional=False, doc=doc_radial_net),
+ Argument("n_axis", [int, None], optional=True, default=None, doc=doc_n_axis),
]
- doc_sknetwork = ""
- return Argument("sknetwork", dict, optional=True, sub_fields=args, sub_variants=[], default={}, doc=doc_sknetwork)
+def baseline():
-def skfunction():
- doc_skformula = r"defines the analytic formula of hoppings like parameters, which depend explicitly on the length of the chemical bonds. Supported type includes: \n\n\
- - powerlaw: $V_{powerlaw}(r_{ij})=alpha_0 * (r_0/r_{ij})^{1+alpha_1}$\n\n\
- - varTang96: $V_{varTang96}(r_{ij})=alpha_0 * r_{ij}^(-\alpha_1) * exp(-\alpha_2 * (rij)^(\alpha_3))$\n\n\
- - custom: the user need to implement a custom formula in the dptb.nnsktb.SKFormula Class \n\n\
- Here $V_{powerlaw}(r) and V_{varTang96}(r)$ is the bond length $r_ij$ dependent formula of fitted parameters. $alpha_{0~3}$ are the parameters fitted by DeePTB. The attained $V(r)$ is then multiplied with a decaying function $f(r)=1+exp((r_{ij}-r_c)/\omega)$ defined by `sk_cutoff` an `sk_decay_w` parameters. Default: `powerlaw` \n\n\
- "
- doc_sk_cutoff = r"The decay param $r_c$ in $f(r)=1+exp((r_{ij}-r_c)/\omega)$, controls the range of the decay, support list input to move the boundary of devaying function from near to afar. Default: 6.0."
- doc_sk_decay_w = r"The decay param $\omega$ in $f(r)=1+exp((r_{ij}-r_c)/\omega)$, control how smooth the decay function is, support list input to move the decaying function from soft to hard. Default: 0.1."
- args = [
- Argument("skformula", str, optional=True, default="powerlaw", doc=doc_skformula),
- Argument("sk_cutoff", [float,int,list], optional=True, default=6.0, doc=doc_sk_cutoff),
- Argument("sk_decay_w", [float, list], optional=True, default=0.1, doc=doc_sk_decay_w)
+ doc_rs = ""
+ doc_rc = ""
+ doc_n_axis = ""
+ doc_radial_embedding = ""
+
+ doc_neurons = ""
+ doc_activation = ""
+ doc_if_batch_normalized = ""
+
+ radial_embedding = [
+ Argument("neurons", list, optional=False, doc=doc_neurons),
+ Argument("activation", str, optional=True, default="tanh", doc=doc_activation),
+ Argument("if_batch_normalized", bool, optional=True, default=False, doc=doc_if_batch_normalized),
]
- doc_skfunction = "The parameter to define the analytic function formula of the SK like integrals."
+ return [
+ Argument("p", [float, int], optional=False, doc=doc_rs),
+ Argument("rc", [float, int], optional=False, doc=doc_rc),
+ Argument("n_basis", int, optional=False, doc=doc_rc),
+ Argument("n_radial", int, optional=False, doc=doc_rc),
+ Argument("n_sqrt_radial", int, optional=False, doc=doc_rc),
+ Argument("n_layer", int, optional=False, doc=doc_rc),
+ Argument("radial_net", dict, sub_fields=radial_embedding, optional=False, doc=doc_radial_embedding),
+ Argument("hidden_net", dict, sub_fields=radial_embedding, optional=False, doc=doc_radial_embedding),
+ Argument("n_axis", [int, None], optional=True, default=None, doc=doc_n_axis),
+ ]
- return Argument("skfunction", dict, optional=True, sub_fields=args, sub_variants=[], default={}, doc=doc_skfunction)
+def deephe3():
+ doc_irreps_embed = ""
+ doc_irreps_mid = ""
+ doc_lmax = ""
+ doc_n_basis = ""
+ doc_rc = ""
+ doc_n_layer = ""
-def onsitefuncion():
- doc_onsite_func_cutoff = r"The decay param controls the range of the decay defined in NRL TB."
- doc_onsite_func_decay_w = r"The decay param control how smooth the decay function is defined in NRL TB."
- doc_onsite_func_lambda = r"the onstie para in NRL TB."
+ return [
+ Argument("irreps_embed", str, optional=True, default="64x0e", doc=doc_irreps_embed),
+ Argument("irreps_mid", str, optional=True, default="64x0e+32x1o+16x2e+8x3o+8x4e+4x5o", doc=doc_irreps_mid),
+ Argument("lmax", int, optional=True, default=3, doc=doc_lmax),
+ Argument("n_basis", int, optional=True, default=128, doc=doc_n_basis),
+ Argument("rc", float, optional=False, doc=doc_rc),
+ Argument("n_layer", int, optional=True, default=3, doc=doc_n_layer),
+ ]
+
+def e3baseline():
+ doc_irreps_hidden = ""
+ doc_lmax = ""
+ doc_avg_num_neighbors = ""
+ doc_n_radial_basis = ""
+ doc_r_max = ""
+ doc_n_layers = ""
+ doc_env_embed_multiplicity = ""
+ doc_linear_after_env_embed = ""
+ doc_latent_resnet_update_ratios_learnable = ""
+ doc_latent_kwargs = ""
- args = [
- Argument("onsite_func_cutoff", [float], optional=True, default=6.0, doc=doc_onsite_func_cutoff),
- Argument("onsite_func_decay_w", [float], optional=True, default=0.5, doc=doc_onsite_func_decay_w),
- Argument("onsite_func_lambda", [float], optional=True, default=1.0, doc=doc_onsite_func_lambda)
- ]
-
- doc_onsitefuncion = "The parameter to define the analytic function formula of the onsite smoth function"
-
- return Argument("onsitefuncion", dict, optional=True, sub_fields=args, sub_variants=[], default={}, doc=doc_onsitefuncion)
-
-def dptb():
- doc_soc_env = "button that allow environmental correction for soc parameters, used only when soc is open, Default: False"
- doc_axis_neuron = "The axis_neuron specifies the size of the submatrix of the embedding matrix, the axis matrix as explained in the [DeepPot-SE paper](https://arxiv.org/abs/1805.09003)."
- doc_onsite_net_neuron = r"The number of hidden neurons in the network for onsites $\langle i|H|i\rangle$ of `dptb` model. Default: `[128, 128, 256, 256]`"
- doc_env_net_neuron = "The number of hidden neurons in the environment embedding network of `dptb` model. Default: `[128, 128, 256, 256]`"
- doc_hopping_net_neuron = r"The number of hidden neurons in the network for hoppings $\langle i|H|j\rangle$ of `dptb` model. Default: `[128, 128, 256, 256]`"
- doc_onsite_net_activation = "The activation function for onsite networks. Default: `tanh`"
- doc_env_net_activation = "The activation function for environment embedding networks. Default: `tanh`"
- doc_hopping_net_activation = "The activation function for hopping networks. Default: `tanh`"
- doc_soc_net_activation = "The activation function for soc networks. Default: `tanh`"
- doc_soc_net_neuron = r"The number of hidden neurons in the network for soc $\lambda$ of `dptb` model. Default: `[128, 128, 256, 256]`"
- doc_soc_net_type = "The network type for soc, the value can be:\n\n\
- - `res`: for feedforward Network with residual connections, for more information about residual network, we refer to [Deep Residual Learning for Image Recognition](https://openaccess.thecvf.com/content_cvpr_2016/papers/He_Deep_Residual_Learning_CVPR_2016_paper.pdf). \n\n\
- - `ffn`: for feedforward Network."
- doc_onsite_net_type = "The network type for onsites."
- doc_env_net_type = "The network type for environment embeddings."
- doc_hopping_net_type = "The network type for hoppings."
- doc_if_batch_normalized = "Whether to use batch normalization after each layer in neural network. The batch normalization normalize the itermidiate values in neural network with the mean and variance estimated in the batch dimension. The batch here means the batch of onsite or hopping embeddings or position vectors that processed by neural network at one time computation, which is different from the batch defined in `data_options`. Default: False."
+ return [
+ Argument("irreps_hidden", str, optional=True, default="64x0e+32x1o+16x2e+8x3o+8x4e+4x5o", doc=doc_irreps_hidden),
+ Argument("lmax", int, optional=True, default=3, doc=doc_lmax),
+ Argument("avg_num_neighbors", [int, float], optional=True, default=50, doc=doc_avg_num_neighbors),
+ Argument("r_max", [float, int, dict], optional=False, doc=doc_r_max),
+ Argument("n_layers", int, optional=True, default=3, doc=doc_n_layers),
+ Argument("n_radial_basis", int, optional=True, default=3, doc=doc_n_radial_basis),
+ Argument("PolynomialCutoff_p", int, optional=True, default=6, doc="The order of polynomial cutoff function. Default: 6"),
+ Argument(
+ "latent_kwargs", dict,
+ optional={
+ "mlp_latent_dimensions": [128, 128, 256],
+ "mlp_nonlinearity": "silu",
+ "mlp_initialization": "uniform"
+ },
+ default=None,
+ doc=doc_latent_kwargs
+ ),
+ Argument("env_embed_multiplicity", int, optional=True, default=1, doc=doc_env_embed_multiplicity),
+ Argument("linear_after_env_embed", bool, optional=True, default=False, doc=doc_linear_after_env_embed),
+ Argument("latent_resnet_update_ratios_learnable", bool, optional=True, default=False, doc=doc_latent_resnet_update_ratios_learnable)
+ ]
+
+
+def prediction():
+ doc_method = ""
+ doc_nn = ""
+ doc_linear = ""
- args = [
- Argument("soc_env", bool, optional=True, default=False, doc=doc_soc_env),
- Argument("axis_neuron", int, optional=True, default=10, doc=doc_axis_neuron),
- Argument("onsite_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_onsite_net_neuron),
- Argument("soc_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_soc_net_neuron),
- Argument("env_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_env_net_neuron),
- Argument("hopping_net_neuron", list, optional=True, default=[128, 128, 256, 256], doc=doc_hopping_net_neuron),
- Argument("onsite_net_activation", str, optional=True, default="tanh", doc=doc_onsite_net_activation),
- Argument("env_net_activation", str, optional=True, default="tanh", doc=doc_env_net_activation),
- Argument("hopping_net_activation", str, optional=True, default="tanh", doc=doc_hopping_net_activation),
- Argument("soc_net_activation", str, optional=True, default="tanh", doc=doc_soc_net_activation),
- Argument("onsite_net_type", str, optional=True, default="res", doc=doc_onsite_net_type),
- Argument("env_net_type", str, optional=True, default="res", doc=doc_env_net_type),
- Argument("hopping_net_type", str, optional=True, default="res", doc=doc_hopping_net_type),
- Argument("soc_net_type", str, optional=True, default="res", doc=doc_soc_net_type),
- Argument("if_batch_normalized", bool, optional=True, default=False, doc=doc_if_batch_normalized)
+ return Variant("method", [
+ Argument("sktb", dict, sktb_prediction(), doc=doc_nn),
+ Argument("e3tb", dict, e3tb_prediction(), doc=doc_nn),
+ ], optional=False, doc=doc_method)
+
+def sktb_prediction():
+ doc_neurons = ""
+ doc_activation = ""
+ doc_if_batch_normalized = ""
+ doc_quantities = ""
+ doc_hamiltonian = ""
+ doc_precision = ""
+
+ nn = [
+ Argument("neurons", list, optional=False, doc=doc_neurons),
+ Argument("activation", str, optional=True, default="tanh", doc=doc_activation),
+ Argument("if_batch_normalized", bool, optional=True, default=False, doc=doc_if_batch_normalized),
+ ]
+
+ return nn
+
+
+def e3tb_prediction():
+ doc_scales_trainable = ""
+ doc_shifts_trainable = ""
+
+ nn = [
+ Argument("scales_trainable", bool, optional=True, default=False, doc=doc_scales_trainable),
+ Argument("shifts_trainable", bool, optional=True, default=False, doc=doc_shifts_trainable),
]
- doc_dptb = "The parameters for `dptb` model, which maps the environmental information to Tight-Binding parameters."
+ return nn
- return Argument("dptb", dict, optional=True, sub_fields=args, sub_variants=[], default={}, doc=doc_dptb)
def model_options():
doc_model_options = "The parameters to define the `nnsk` and `dptb` model."
+ doc_embedding = ""
+ doc_prediction = ""
+
+ return Argument("model_options", dict, sub_fields=[
+ Argument("embedding", dict, optional=True, sub_fields=[], sub_variants=[embedding()], doc=doc_embedding),
+ Argument("prediction", dict, optional=True, sub_fields=[], sub_variants=[prediction()], doc=doc_prediction),
+ nnsk(),
+ ], sub_variants=[], optional=True, doc=doc_model_options)
+
+def nnsk():
+ doc_nnsk = ""
+ doc_onsite = ""
+ doc_hopping = ""
+ doc_freeze = ""
+ doc_std = ""
+
+ # overlap = Argument("overlap", bool, optional=True, default=False, doc="The parameters to define the overlap correction of nnsk model.")
+
+ return Argument("nnsk", dict, sub_fields=[
+ Argument("onsite", dict, optional=False, sub_fields=[], sub_variants=[onsite()], doc=doc_onsite),
+ Argument("hopping", dict, optional=False, sub_fields=[], sub_variants=[hopping()], doc=doc_hopping),
+ Argument("freeze", bool, optional=True, default=False, doc=doc_freeze),
+ Argument("std", float, optional=True, default=0.01, doc=doc_std),
+ push(),
+ ], sub_variants=[], optional=True, doc=doc_nnsk)
+
+def push():
+ doc_rs_thr = ""
+ doc_rc_thr = ""
+ doc_w_thr = ""
+ doc_period = ""
+
+ return Argument("push", dict, sub_fields=[
+ Argument("rs_thr", float, optional=True, default=0., doc=doc_rs_thr),
+ Argument("rc_thr", float, optional=True, default=0., doc=doc_rc_thr),
+ Argument("w_thr", float, optional=True, default=0., doc=doc_w_thr),
+ Argument("period", int, optional=True, default=100, doc=doc_period),
+ ], sub_variants=[], optional=True, default={}, doc="The parameters to define the push the soft cutoff of nnsk model.")
+
+def onsite():
+ doc_method = r"The onsite correction mode, the onsite energy is expressed as the energy of isolated atoms plus the model correction, the correction mode are:\n\n\
+ - `strain`: The strain mode correct the onsite matrix densly by $$H_{i,i}^{lm,l^\prime m^\prime} = \epsilon_l^0 \delta_{ll^\prime}\delta_{mm^\prime} + \sum_p \sum_{\zeta} \Big[ \mathcal{U}_{\zeta}(\hat{\br}_{ip}) \ \epsilon_{ll^\prime \zeta} \Big]_{mm^\prime}$$ which is also parameterized as a set of Slater-Koster like integrals.\n\n\
+ - `uniform`: The correction is a energy shift respect of orbital of each atom. Which is formally written as: \n\n\
+ $$H_{i,i}^{lm,l^\prime m^\prime} = (\epsilon_l^0+\epsilon_l^\prime) \delta_{ll^\prime}\delta_{mm^\prime}$$ Where $\epsilon_l^0$ is the isolated energy level from the DeePTB onsite database, and $\epsilon_l^\prime$ is the parameters to fit. E.p. \n\n\
+ - `split`: (not recommanded) The split onsite mode correct onsite hamiltonian with a magnetic quantum number dependent form, which violate the rotation equivariace, but some times can be effective. The formula is: \
+ $$H_{i,i}^{lm,l^\prime m^\prime} = (\epsilon_l^0+\epsilon_{lm}^\prime) \delta_{ll^\prime}\delta_{mm^\prime}$$ \n\n\
+ Default: `none`"
+
+ doc_rs = ""
+ doc_w = ""
+ doc_rc = ""
+ doc_lda = ""
+
+ strain = [
+ Argument("rs", float, optional=True, default=6.0, doc=doc_rs),
+ Argument("w", float, optional=True, default=0.1, doc=doc_w),
+ ]
- return Argument("model_options", dict, sub_fields=[skfunction(), sknetwork(), onsitefuncion(), dptb()], sub_variants=[], optional=False, doc=doc_model_options)
+ NRL = [
+ Argument("rc", float, optional=True, default=6.0, doc=doc_rc),
+ Argument("w", float, optional=True, default=0.1, doc=doc_w),
+ Argument("lda", float, optional=True, default=1.0, doc=doc_lda)
+ ]
+ return Variant("method", [
+ Argument("strain", dict, strain),
+ Argument("uniform", dict, []),
+ Argument("NRL", dict, NRL),
+ Argument("none", dict, []),
+ ],optional=False, doc=doc_method)
+
+def hopping():
+ doc_method = ""
+ doc_rs = ""
+ doc_w = ""
+ doc_rc = ""
+
+ powerlaw = [
+ Argument("rs", float, optional=True, default=6.0, doc=doc_rs),
+ Argument("w", float, optional=True, default=0.1, doc=doc_w),
+ ]
+
+ varTang96 = [
+ Argument("rs", float, optional=True, default=6.0, doc=doc_rs),
+ Argument("w", float, optional=True, default=0.1, doc=doc_w),
+ ]
+
+ NRL = [
+ Argument("rc", float, optional=True, default=6.0, doc=doc_rc),
+ Argument("w", float, optional=True, default=0.1, doc=doc_w),
+ ]
+
+
+ return Variant("method", [
+ Argument("powerlaw", dict, powerlaw),
+ Argument("varTang96", dict, varTang96),
+ Argument("NRL0", dict, NRL),
+ Argument("NRL1", dict, NRL),
+ Argument("custom", dict, []),
+ ],optional=False, doc=doc_method)
+
def loss_options():
- doc_losstype = "The loss function type, defined by a string like `_`, Default: `eigs_l2dsf`. supported loss functions includes:\n\n\
+ doc_method = "The loss function type, defined by a string like `_`, Default: `eigs_l2dsf`. supported loss functions includes:\n\n\
- `eig_l2`: The l2 norm of predicted and labeled eigenvalues.\n\n\
- `eigs_l2d`: The l2 norm and the random differences of the predicted and labeled eigenvalues.\n\n\
- `block_l2`: \n\n\
Notice: The loss option define here only affect the training loss function, the loss for evaluation will always be `eig_l2`, as it compute the standard MSE of fitted eigenvalues."
- doc_sortstrength = ""
- doc_nkratio = "The ratio is `null` or a positive float value smaller than `1.0`. If equals some float type, DeePTB will randomly select 100*ratio % of eigenvalues to compute the error and backpropagate to train the models. Default: None."
+ doc_train = ""
+ doc_validation = ""
+ doc_reference = ""
+
+ loss_args = Variant("method", [
+ Argument("hamil", dict, []),
+ Argument("eigvals", dict, []),
+ Argument("hamil_abs", dict, []),
+ ], optional=False, doc=doc_method)
args = [
- Argument("losstype", str, optional=True, doc=doc_losstype, default='eigs_l2dsf'),
- Argument("sortstrength", list, optional=True, doc=doc_sortstrength,default=[0.01,0.01]),
- Argument("nkratio", [float,None], optional=True, doc=doc_nkratio, default=None)
+ Argument("train", dict, optional=False, sub_fields=[], sub_variants=[loss_args], doc=doc_train),
+ Argument("validation", dict, optional=True, sub_fields=[], sub_variants=[loss_args], doc=doc_validation),
+ Argument("reference", dict, optional=True, sub_fields=[], sub_variants=[loss_args], doc=doc_reference),
]
doc_loss_options = ""
- return Argument("loss_options", dict, sub_fields=args, sub_variants=[], optional=True, default={}, doc=doc_loss_options)
+ return Argument("loss_options", dict, sub_fields=args, sub_variants=[], optional=False, doc=doc_loss_options)
def normalize(data):
- ini = init_model()
-
co = common_options()
tr = train_options()
da = data_options()
mo = model_options()
- lo = loss_options()
- base = Argument("base", dict, [ini, co, tr, da, mo, lo])
+ base = Argument("base", dict, [co, tr, da, mo])
data = base.normalize_value(data)
# data = base.normalize_value(data, trim_pattern="_*")
base.check_value(data, strict=True)
# add check loss and use wannier:
- if data['data_options']['use_wannier']:
- if not data['loss_options']['losstype'] .startswith("block"):
- log.info(msg='\n Warning! set data_options use_wannier true, but the loss type is not block_l2! The the wannier TB will not be used when training!\n')
+ # if data['data_options']['use_wannier']:
+ # if not data['loss_options']['losstype'] .startswith("block"):
+ # log.info(msg='\n Warning! set data_options use_wannier true, but the loss type is not block_l2! The the wannier TB will not be used when training!\n')
- if data['loss_options']['losstype'] .startswith("block"):
- if not data['data_options']['use_wannier']:
- log.error(msg="\n ERROR! for block loss type, must set data_options:use_wannier True\n")
- raise ValueError
+ # if data['loss_options']['losstype'] .startswith("block"):
+ # if not data['data_options']['use_wannier']:
+ # log.error(msg="\n ERROR! for block loss type, must set data_options:use_wannier True\n")
+ # raise ValueError
return data
-def normalize_test(data):
+# def normalize_restart(data):
+
+# co = common_options()
+# da = data_options()
+
+# base = Argument("base", dict, [co, da])
+# data = base.normalize_value(data)
+# # data = base.normalize_value(data, trim_pattern="_*")
+# base.check_value(data, strict=True)
+
+# # add check loss and use wannier:
+
+# # if data['data_options']['use_wannier']:
+# # if not data['loss_options']['losstype'] .startswith("block"):
+# # log.info(msg='\n Warning! set data_options use_wannier true, but the loss type is not block_l2! The the wannier TB will not be used when training!\n')
+
+# # if data['loss_options']['losstype'] .startswith("block"):
+# # if not data['data_options']['use_wannier']:
+# # log.error(msg="\n ERROR! for block loss type, must set data_options:use_wannier True\n")
+# # raise ValueError
- ini = init_model()
+# return data
+
+# def normalize_init_model(data):
+
+# co = common_options()
+# da = data_options()
+# tr = train_options()
+
+# base = Argument("base", dict, [co, da, tr])
+# data = base.normalize_value(data)
+# # data = base.normalize_value(data, trim_pattern="_*")
+# base.check_value(data, strict=True)
+
+# # add check loss and use wannier:
+
+# # if data['data_options']['use_wannier']:
+# # if not data['loss_options']['losstype'] .startswith("block"):
+# # log.info(msg='\n Warning! set data_options use_wannier true, but the loss type is not block_l2! The the wannier TB will not be used when training!\n')
+
+# # if data['loss_options']['losstype'] .startswith("block"):
+# # if not data['data_options']['use_wannier']:
+# # log.error(msg="\n ERROR! for block loss type, must set data_options:use_wannier True\n")
+# # raise ValueError
+
+# return data
+
+def normalize_test(data):
co = common_options()
da = test_data_options()
- mo = model_options()
+ to = test_options()
lo = loss_options()
- base = Argument("base", dict, [ini, co, da, mo, lo])
+ base = Argument("base", dict, [co, da, to, lo])
data = base.normalize_value(data)
# data = base.normalize_value(data, trim_pattern="_*")
base.check_value(data, strict=True)
@@ -673,13 +958,8 @@ def normalize_run(data):
]
co = Argument("common_options", dict, optional=True, sub_fields=args, sub_variants=[], doc=doc_common_options)
- ini = init_model()
- mo = Argument("model_options", dict, sub_fields=[skfunction(), sknetwork(),onsitefuncion(), dptb()], sub_variants=[], optional=True, doc=doc_model_options)
-
args = [
- ini,
co,
- mo,
Argument("structure", [str,None], optional=True, default=None, doc = doc_structure),
Argument("use_correction", [str,None], optional=True, default=None, doc = doc_use_correction),
Argument("use_gui", bool, optional=True, default=False, doc = doc_gui),
@@ -904,11 +1184,10 @@ def write_sk():
def host_normalize(data):
- ini = init_model()
co = common_options()
mo = model_options()
- base = Argument("base", dict, [ini, co, mo])
+ base = Argument("base", dict, [co, mo])
data = base.normalize_value(data)
# data = base.normalize_value(data, trim_pattern="_*")
base.check_value(data, strict=False)
@@ -948,3 +1227,54 @@ def normalize_bandinfo(data):
return data
+def bandinfo_sub():
+ doc_nkpoints = ""
+ doc_nbands = ""
+ doc_band_min = ""
+ doc_band_max = ""
+ doc_emin = ""
+ doc_emax = ""
+
+ args = [
+ Argument("nkpoints", int, optional=True, doc=doc_nkpoints, default=0),
+ Argument("nbands", int, optional=True, doc=doc_nbands, default=0),
+ Argument("band_min", int, optional=True, doc=doc_band_min, default=0),
+ Argument("band_max", [int, None], optional=True, doc=doc_band_max, default=None),
+ Argument("emin", [float, None], optional=True, doc=doc_emin,default=None),
+ Argument("emax", [float, None], optional=True, doc=doc_emax,default=None),
+ ]
+
+ return Argument("bandinfo", dict, optional=True, sub_fields=args, sub_variants=[], doc="")
+
+def AtomicData_options_sub():
+ doc_r_max = ""
+ doc_er_max = ""
+ doc_oer_max = ""
+ doc_pbc = ""
+
+ args = [
+ Argument("r_max", float, optional=False, doc=doc_r_max, default=4.0),
+ Argument("er_max", float, optional=True, doc=doc_er_max, default=None),
+ Argument("oer_max", float, optional=True, doc=doc_oer_max,default=None),
+ Argument("pbc", bool, optional=False, doc=doc_pbc, default=True),
+ ]
+
+ return Argument("AtomicData_options", dict, optional=False, sub_fields=args, sub_variants=[], doc="")
+
+def normalize_setinfo(data):
+ doc_nframes = "Number of frames in this trajectory."
+ doc_natoms = "Number of atoms in each frame."
+ doc_pos_type = "Type of atomic position input. Can be frac / cart / ase."
+
+ args = [
+ Argument("nframes", int, optional=False, doc=doc_nframes),
+ Argument("natoms", int, optional=False, doc=doc_natoms),
+ Argument("pos_type", str, optional=False, doc=doc_pos_type),
+ bandinfo_sub(),
+ AtomicData_options_sub()
+ ]
+ setinfo = Argument("setinfo", dict, sub_fields=args)
+ data = setinfo.normalize_value(data)
+ setinfo.check_value(data, strict=True)
+
+ return data
\ No newline at end of file
diff --git a/dptb/utils/auto_init.py b/dptb/utils/auto_init.py
new file mode 100644
index 00000000..82d9cd2a
--- /dev/null
+++ b/dptb/utils/auto_init.py
@@ -0,0 +1,314 @@
+from typing import Optional, Union, List
+import inspect
+import logging
+
+from .config import Config, _GLOBAL_ALL_ASKED_FOR_KEYS
+
+
+def instantiate_from_cls_name(
+ module,
+ class_name: str,
+ prefix: Optional[Union[str, List[str]]] = [],
+ positional_args: dict = {},
+ optional_args: Optional[dict] = None,
+ all_args: Optional[dict] = None,
+ remove_kwargs: bool = True,
+ return_args_only: bool = False,
+):
+ """Initialize a class based on a string class name
+
+ Args:
+ module: the module to import the class, i.e. torch.optim
+ class_name: the string name of the class, i.e. "CosineAnnealingWarmRestarts"
+ positional_args (dict): positional arguments
+ optional_args (optional, dict): optional arguments
+ all_args (dict): list of all candidate parameters tha could potentially match the argument list
+ remove_kwargs: if True, ignore the kwargs argument in the init funciton
+ same definition as the one in Config.from_function
+ return_args_only (bool): if True, do not instantiate, only return the arguments
+
+ Returns:
+
+ instance: the instance
+ optional_args (dict):
+ """
+
+ if class_name is None:
+ raise NameError("class_name type is not defined ")
+
+ # first obtain a list of all classes in this module
+ class_list = inspect.getmembers(module, inspect.isclass)
+ class_dict = {}
+ for k, v in class_list:
+ class_dict[k] = v
+
+ # find the matching class
+ the_class = class_dict.get(class_name, None)
+ if the_class is None:
+ raise NameError(f"{class_name} type is not found in {module.__name__} module")
+
+ return instantiate(
+ builder=the_class,
+ prefix=prefix,
+ positional_args=positional_args,
+ optional_args=optional_args,
+ all_args=all_args,
+ remove_kwargs=remove_kwargs,
+ return_args_only=return_args_only,
+ )
+
+
+def instantiate(
+ builder,
+ prefix: Optional[Union[str, List[str]]] = [],
+ positional_args: dict = {},
+ optional_args: dict = None,
+ all_args: dict = None,
+ remove_kwargs: bool = True,
+ return_args_only: bool = False,
+ parent_builders: list = [],
+):
+
+ """Automatic initializing class instance by matching keys in the parameter dictionary to the constructor function.
+
+ Keys that are exactly the same, or with a 'prefix_' in all_args, optional_args will be used.
+ Priority:
+
+ all_args[key] < all_args[prefix_key] < optional_args[key] < optional_args[prefix_key] < positional_args
+
+ Args:
+ builder: the type of the instance
+ prefix: the prefix used to address the parameter keys
+ positional_args: the arguments used for input. These arguments have the top priority.
+ optional_args: the second priority group to search for keys.
+ all_args: the third priority group to search for keys.
+ remove_kwargs: if True, ignore the kwargs argument in the init funciton
+ same definition as the one in Config.from_function
+ return_args_only (bool): if True, do not instantiate, only return the arguments
+ """
+
+ prefix_list = [builder.__name__] if inspect.isclass(builder) else []
+ if isinstance(prefix, str):
+ prefix_list += [prefix] # a list of class name
+ elif isinstance(prefix, list):
+ prefix_list += prefix
+ else:
+ raise ValueError(f"prefix has the wrong type {type(prefix)}")
+
+ # detect the input parameters needed from params
+ config = Config.from_class(builder, remove_kwargs=remove_kwargs)
+
+ # be strict about _kwargs keys:
+ allow = config.allow_list()
+ for key in allow:
+ bname = key[:-7]
+ if key.endswith("_kwargs") and bname not in allow:
+ raise KeyError(
+ f"Instantiating {builder.__name__}: found kwargs argument `{key}`, but no parameter `{bname}` for the corresponding builder. (Did you rename `{bname}` but forget to change `{bname}_kwargs`?) Either add a parameter for `{bname}` if you are trying to allow construction of a submodule, or, if `{bname}_kwargs` is just supposed to be a dictionary, rename it without `_kwargs`."
+ )
+ del allow
+
+ key_mapping = {}
+ if all_args is not None:
+ # fetch paratemeters that directly match the name
+ _keys = config.update(all_args)
+ key_mapping["all"] = {k: k for k in _keys}
+ # fetch paratemeters that match prefix + "_" + name
+ for idx, prefix_str in enumerate(prefix_list):
+ _keys = config.update_w_prefix(
+ all_args,
+ prefix=prefix_str,
+ )
+ key_mapping["all"].update(_keys)
+
+ if optional_args is not None:
+ # fetch paratemeters that directly match the name
+ _keys = config.update(optional_args)
+ key_mapping["optional"] = {k: k for k in _keys}
+ # fetch paratemeters that match prefix + "_" + name
+ for idx, prefix_str in enumerate(prefix_list):
+ _keys = config.update_w_prefix(
+ optional_args,
+ prefix=prefix_str,
+ )
+ key_mapping["optional"].update(_keys)
+
+ # for logging only, remove the overlapped keys
+ if "all" in key_mapping and "optional" in key_mapping:
+ key_mapping["all"] = {
+ k: v
+ for k, v in key_mapping["all"].items()
+ if k not in key_mapping["optional"]
+ }
+
+ final_optional_args = Config.as_dict(config)
+
+ # for nested argument, it is possible that the positional args contain unnecesary keys
+ if len(parent_builders) > 0:
+ _positional_args = {
+ k: v for k, v in positional_args.items() if k in config.allow_list()
+ }
+ positional_args = _positional_args
+
+ init_args = final_optional_args.copy()
+ init_args.update(positional_args)
+
+ # find out argument for the nested keyword
+ search_keys = [key for key in init_args if key + "_kwargs" in config.allow_list()]
+ for key in search_keys:
+ sub_builder = init_args[key]
+ if sub_builder is None:
+ # if the builder is None, skip it
+ continue
+
+ if not (callable(sub_builder) or inspect.isclass(sub_builder)):
+ raise ValueError(
+ f"Builder for submodule `{key}` must be a callable or a class, got `{sub_builder!r}` instead."
+ )
+
+ # add double check to avoid cycle
+ # only overwrite the optional argument, not the positional ones
+ if (
+ sub_builder not in parent_builders
+ and key + "_kwargs" not in positional_args
+ ):
+ sub_prefix_list = [sub_builder.__name__, key]
+ for prefix in prefix_list:
+ sub_prefix_list = sub_prefix_list + [
+ prefix,
+ prefix + "_" + key,
+ ]
+
+ nested_km, nested_kwargs = instantiate(
+ sub_builder,
+ prefix=sub_prefix_list,
+ positional_args=positional_args,
+ optional_args=optional_args,
+ all_args=all_args,
+ remove_kwargs=remove_kwargs,
+ return_args_only=True,
+ parent_builders=[builder] + parent_builders,
+ )
+ # the values in kwargs get higher priority
+ nested_kwargs.update(final_optional_args.get(key + "_kwargs", {}))
+ final_optional_args[key + "_kwargs"] = nested_kwargs
+
+ for t in key_mapping:
+ key_mapping[t].update(
+ {key + "_kwargs." + k: v for k, v in nested_km[t].items()}
+ )
+ elif sub_builder in parent_builders:
+ raise RuntimeError(
+ f"cyclic recursion in builder {parent_builders} {sub_builder}"
+ )
+ elif not callable(sub_builder) and not inspect.isclass(sub_builder):
+ logging.warning(f"subbuilder is not callable {sub_builder}")
+ elif key + "_kwargs" in positional_args:
+ logging.warning(
+ f"skip searching for nested argument because {key}_kwargs are defined in positional arguments"
+ )
+
+ # remove duplicates
+ for key in positional_args:
+ final_optional_args.pop(key, None)
+ for t in key_mapping:
+ key_mapping[t].pop(key, None)
+
+ # debug info
+ if len(parent_builders) == 0:
+ # ^ we only want to log or consume arguments for the "unused keys" check
+ # if this is a root-level build. For subbuilders, we don't want to log
+ # or, worse, mark keys without prefixes as consumed.
+ logging.debug(
+ f"{'get args for' if return_args_only else 'instantiate'} {builder.__name__}"
+ )
+ for t in key_mapping:
+ for k, v in key_mapping[t].items():
+ string = f" {t:>10s}_args : {k:>50s}"
+ # key mapping tells us how values got from the
+ # users config (v) to the object being built (k)
+ # thus v is by definition a valid key
+ _GLOBAL_ALL_ASKED_FOR_KEYS.add(v)
+ if k != v:
+ string += f" <- {v:>50s}"
+ logging.debug(string)
+ logging.debug(f"...{builder.__name__}_param = dict(")
+ logging.debug(f"... optional_args = {final_optional_args},")
+ logging.debug(f"... positional_args = {positional_args})")
+
+ # Short circuit for return_args_only
+ if return_args_only:
+ return key_mapping, final_optional_args
+ # Otherwise, actually build the thing:
+ try:
+ instance = builder(**positional_args, **final_optional_args)
+ except Exception as e:
+ raise RuntimeError(
+ f"Failed to build object with prefix `{prefix}` using builder `{builder.__name__}`"
+ ) from e
+
+ return instance, final_optional_args
+
+
+def get_w_prefix(
+ key: List[str],
+ *kwargs,
+ arg_dicts: List[dict] = [],
+ prefix: Optional[Union[str, List[str]]] = [],
+):
+ """
+ act as the get function and try to search for the value key from arg_dicts
+ """
+
+ # detect the input parameters needed from params
+ config = Config(config={}, allow_list=[key])
+
+ # sort out all possible prefixes
+ if isinstance(prefix, str):
+ prefix_list = [prefix]
+ elif isinstance(prefix, list):
+ prefix_list = prefix
+ else:
+ raise ValueError(f"prefix is with a wrong type {type(prefix)}")
+
+ if not isinstance(arg_dicts, list):
+ arg_dicts = [arg_dicts]
+
+ # extract all the parameters that has the pattern prefix_variable
+ # debug container to record all the variable name transformation
+ key_mapping = {}
+ for idx, arg_dict in enumerate(arg_dicts[::-1]):
+ # fetch paratemeters that directly match the name
+ _keys = config.update(arg_dict)
+ key_mapping[idx] = {k: k for k in _keys}
+ # fetch paratemeters that match prefix + "_" + name
+ for idx, prefix_str in enumerate(prefix_list):
+ _keys = config.update_w_prefix(
+ arg_dict,
+ prefix=prefix_str,
+ )
+ key_mapping[idx].update(_keys)
+
+ # for logging only, remove the overlapped keys
+ num_dicts = len(arg_dicts)
+ if num_dicts > 1:
+ for id_dict in range(num_dicts - 1):
+ higher_priority_keys = []
+ for id_higher in range(id_dict + 1, num_dicts):
+ higher_priority_keys += list(key_mapping[id_higher].keys())
+ key_mapping[id_dict] = {
+ k: v
+ for k, v in key_mapping[id_dict].items()
+ if k not in higher_priority_keys
+ }
+
+ # debug info
+ logging.debug(f"search for {key} with prefix {prefix}")
+ for t in key_mapping:
+ for k, v in key_mapping[t].items():
+ string = f" {str(t):>10.10}_args : {k:>50s}"
+ if k != v:
+ string += f" <- {v:>50s}"
+ logging.debug(string)
+
+ return config.get(key, *kwargs)
diff --git a/dptb/utils/batch_ops.py b/dptb/utils/batch_ops.py
new file mode 100644
index 00000000..6740661e
--- /dev/null
+++ b/dptb/utils/batch_ops.py
@@ -0,0 +1,31 @@
+from typing import Optional
+
+import torch
+
+
+def bincount(
+ input: torch.Tensor, batch: Optional[torch.Tensor] = None, minlength: int = 0
+):
+ assert input.ndim == 1
+ if batch is None:
+ return torch.bincount(input, minlength=minlength)
+ else:
+ assert batch.shape == input.shape
+
+ length = input.max().item() + 1
+ if minlength == 0:
+ minlength = length
+ if length > minlength:
+ raise ValueError(
+ f"minlength {minlength} too small for input with integers up to and including {length}"
+ )
+
+ # Flatten indexes
+ # Make each "class" in input into a per-input class.
+ input = input + batch * minlength
+
+ num_batch = batch.max() + 1
+
+ return torch.bincount(input, minlength=minlength * num_batch).reshape(
+ num_batch, minlength
+ )
diff --git a/dptb/utils/config.py b/dptb/utils/config.py
new file mode 100644
index 00000000..47555875
--- /dev/null
+++ b/dptb/utils/config.py
@@ -0,0 +1,392 @@
+"""
+Class to holde a bunch of hyperparameters associate with either training or a model.
+
+The interface is inteneded to be as close to the wandb.config class as possible. But it does not have any locked
+entries as in wandb.config
+
+Examples:
+
+ Initialization
+ ```
+ config = Config()
+ config = Config(dict(a=1, b=2))
+ ```
+
+ add a new parameter
+
+ ```
+ config['key'] = default_value
+ config.key = default_value
+ ```
+
+ set up typehint for a parameter
+ ```
+ config['_key_type'] = int
+ config._key_type = int
+ config.set_type(key, int)
+ ```
+
+ update with a dictionary
+ ```
+ config.update(dictionary={'a':3, 'b':4})
+ ```
+
+ If a parameter is updated, the updated value will be formatted back to the same type.
+
+"""
+from typing import Set, Dict, Any, List
+
+import inspect
+
+from copy import deepcopy
+from typing import Optional
+
+from dptb.utils.savenload import save_file, load_file
+
+
+_GLOBAL_ALL_ASKED_FOR_KEYS: Set[str] = set()
+
+
+class Config(object):
+ _items: Dict[str, Any]
+
+ def __init__(
+ self,
+ config: Optional[dict] = None,
+ allow_list: Optional[list] = None,
+ exclude_keys: Optional[list] = None,
+ ):
+
+ object.__setattr__(self, "_items", dict())
+ object.__setattr__(self, "_item_types", dict())
+ object.__setattr__(self, "_allow_list", list())
+ object.__setattr__(self, "_allow_all", True)
+
+ if allow_list is not None:
+ self.add_allow_list(allow_list, default_values={})
+
+ if config is not None and exclude_keys is not None:
+ config = {
+ key: value for key, value in config.items() if key not in exclude_keys
+ }
+ if config is not None:
+ self.update(config)
+
+ def __repr__(self):
+ return str(dict(self))
+
+ __str__ = __repr__
+
+ def keys(self):
+ return self._items.keys()
+
+ def _as_dict(self):
+ return self._items
+
+ @staticmethod
+ def as_dict(obj):
+ # don't use `dict(self)`, since that
+ # calls __getitem__
+ if isinstance(obj, dict):
+ return obj.copy()
+ elif isinstance(obj, Config):
+ return obj._items.copy()
+ else:
+ raise TypeError
+
+ def __getitem__(self, key):
+ # any requested key is a valid key
+ _GLOBAL_ALL_ASKED_FOR_KEYS.add(key)
+ return self._items[key]
+
+ def get_type(self, key):
+ """Get Typehint from item_types dict or previous defined value
+ Args:
+
+ key: name of the variable
+ """
+
+ return self._item_types.get(key, None)
+
+ def set_type(self, key, typehint):
+ """set typehint for a variable
+
+ Args:
+
+ key: name of the variable
+ typehint: type of the variable
+ """
+
+ self._item_types[key] = typehint
+
+ def add_allow_list(self, keys, default_values={}):
+ """add key to allow_list"""
+
+ object.__setattr__(self, "_allow_all", False)
+ object.__setattr__(
+ self, "_allow_list", list(set(self._allow_list).union(set(keys)))
+ )
+ self.update(default_values)
+
+ def allow_list(self):
+ return self._allow_list
+
+ def __setitem__(self, key, val):
+ # typehint
+ if key.endswith("_type") and key.startswith("_"):
+
+ k = key[1:-5]
+ if (not self._allow_all) and key not in self._allow_list:
+ return None
+
+ self._item_types[k] = val
+
+ # normal value
+ else:
+
+ if (not self._allow_all) and key not in self._allow_list:
+ return None
+
+ typehint = self.get_type(key)
+
+ # try to format the variable
+ try:
+ val = typehint(val) if typehint is not None else val
+ except Exception:
+ raise TypeError(
+ f"Wrong Type: Parameter {key} should be {typehint} type."
+ f"But {type(val)} is given"
+ )
+
+ self._items[key] = deepcopy(val)
+ return key
+
+ def items(self):
+ return self._items.items()
+
+ __setattr__ = __setitem__
+
+ def __getattr__(self, key):
+ return self.__getitem__(key)
+
+ def __contains__(self, key):
+ return key in self._items
+
+ def pop(self, *args):
+ _GLOBAL_ALL_ASKED_FOR_KEYS.add(args[0])
+ return self._items.pop(*args)
+
+ def update_w_prefix(
+ self,
+ dictionary: dict,
+ prefix: str,
+ allow_val_change=None,
+ ):
+ """Mock of wandb.config function
+
+ Add a dictionary of parameters to the
+ The key of the parameter cannot be started as "_"
+
+ Args:
+
+ dictionary (dict): dictionary of parameters and their typehint to update
+ allow_val_change (None): mock for wandb.config, not used.
+
+ Returns:
+
+ """
+
+ # override with prefix
+ l_prefix = len(prefix) + 1
+ prefix_dict = {
+ k[l_prefix:]: v for k, v in dictionary.items() if k.startswith(prefix + "_")
+ }
+ keys = self.update(prefix_dict, allow_val_change=allow_val_change)
+ keys = {k: f"{prefix}_{k}" for k in keys}
+
+ for suffix in ["kwargs"]:
+ if f"{prefix}_{suffix}" in dictionary:
+ key3 = self.update(
+ dictionary[f"{prefix}_{suffix}"],
+ allow_val_change=allow_val_change,
+ )
+ keys.update({k: f"{prefix}_{suffix}.{k}" for k in key3})
+ return keys
+
+ def update(self, dictionary: dict, allow_val_change=None):
+ """Mock of wandb.config function
+
+ Add a dictionary of parameters to the config
+ The key of the parameter cannot be started as "_"
+
+ Args:
+
+ dictionary (dict): dictionary of parameters and their typehint to update
+ allow_val_change (None): mock for wandb.config, not used.
+
+ Returns:
+ keys (set): set of keys being udpated
+
+ """
+
+ keys = []
+
+ # first log in all typehints or hidden variables
+ for k, value in dictionary.items():
+ if k.startswith("_"):
+ keys += [self.__setitem__(k, value)]
+
+ # then log in the values
+ for k, value in dictionary.items():
+ if not k.startswith("_"):
+ keys += [self.__setitem__(k, value)]
+
+ return set(keys) - set([None])
+
+ def get(self, *args):
+ _GLOBAL_ALL_ASKED_FOR_KEYS.add(args[0])
+ return self._items.get(*args)
+
+ def persist(self):
+ """mock wandb.config function"""
+ pass
+
+ def setdefaults(self, d):
+ """mock wandb.config function"""
+ pass
+
+ def update_locked(self, d, user=None):
+ """mock wandb.config function"""
+ pass
+
+ def save(self, filename: str, format: Optional[str] = None):
+ """Print config to file."""
+
+ supported_formats = {"yaml": ("yml", "yaml"), "json": "json"}
+ return save_file(
+ item=dict(self),
+ supported_formats=supported_formats,
+ filename=filename,
+ enforced_format=format,
+ )
+
+ @staticmethod
+ def from_file(filename: str, format: Optional[str] = None, defaults: dict = {}):
+ """Load arguments from file
+
+ Has support for including another config file as a baseline with:
+ ```
+ # example of using another config as a baseline and overriding only selected options
+ # this option will read in configs/minimal.yaml and take ALL keys from that file
+ include_file_as_baseline_config: configs/minimal.yaml
+ # keys specified in this file WILL OVERRIDE keys from the `include_file_as_baseline_config` file
+ l_max: 1 # overrides l_max: 2 in minimal.yaml
+ ```
+ """
+
+ supported_formats = {"yaml": ("yml", "yaml"), "json": "json"}
+ dictionary = load_file(
+ supported_formats=supported_formats,
+ filename=filename,
+ enforced_format=format,
+ )
+ k: str = "include_file_as_baseline_config"
+ if k in dictionary:
+ # allow one level of subloading
+ baseline_fname = dictionary.pop(k)
+ dictionary_baseline = load_file(
+ supported_formats=supported_formats,
+ filename=baseline_fname,
+ enforced_format=format,
+ )
+ if k in dictionary_baseline:
+ raise NotImplementedError(
+ f"Multiple levels of `{k}` are not allowed, but {baseline_fname} contained `{k}`"
+ )
+ # override baseline options with the main config
+ dictionary_baseline.update(dictionary)
+ dictionary = dictionary_baseline
+ del dictionary_baseline, baseline_fname
+ return Config.from_dict(dictionary, defaults)
+
+ @staticmethod
+ def from_dict(dictionary: dict, defaults: dict = {}):
+ c = Config(defaults)
+ c.update(dictionary)
+ return c
+
+ @staticmethod
+ def from_class(class_type, remove_kwargs: bool = False):
+ """return Config class instance based on init function of the input class
+ the instance will only allow to store init function related variables
+ the type hints are all set to None, so no automatic format conversion is applied
+
+ class_type: torch.module children class type, i.e. .nequip.Nequip
+ remove_kwargs (optional, bool): the same as Config.from_function
+
+ Returns:
+
+ config (Config):
+ """
+
+ if inspect.isclass(class_type):
+ return Config.from_function(
+ class_type.__init__, remove_kwargs=remove_kwargs
+ )
+ elif callable(class_type):
+ return Config.from_function(class_type, remove_kwargs=remove_kwargs)
+ else:
+ raise ValueError(
+ f"from_class only takes class type or callable, but got {class_type}"
+ )
+
+ @staticmethod
+ def from_function(function, remove_kwargs=False):
+ """return Config class instance based on the function of the input class
+ the instance will only allow to store init function related variables
+ the type hints are all set to None, so no automatic format conversion is applied
+
+ Args:
+
+ function: function name
+ remove_kwargs (optional, bool): if True, kwargs are removed from the keys
+ and the returned instance will only takes the init params of the class_type.
+ if False and kwargs exists, the config only initialized with the default param values,
+ but it can take any other keys
+
+ Returns:
+
+ config (Config):
+ """
+
+ sig = inspect.signature(function)
+
+ default_params = {
+ k: v.default
+ for k, v in sig.parameters.items()
+ if v.default is not inspect.Parameter.empty
+ }
+ param_keys = list(sig.parameters.keys())
+ if param_keys[0] == "self":
+ param_keys = param_keys[1:]
+
+ for key in param_keys:
+ default_params[f"_{key}_type"] = None
+
+ # do not restrict variables when kwargs exists
+ if "kwargs" in param_keys and not remove_kwargs:
+ return Config(config=default_params)
+ elif "kwargs" in param_keys:
+ param_keys.remove("kwargs")
+ return Config(config=default_params, allow_list=param_keys)
+ else:
+ return Config(config=default_params, allow_list=param_keys)
+
+ load = from_file
+
+ def _get_nomark(self, key: str) -> Any:
+ return self._items.get(key)
+
+ def _unused_keys(self) -> List[str]:
+ unused = [k for k in self.keys() if k not in _GLOBAL_ALL_ASKED_FOR_KEYS]
+ return unused
diff --git a/dptb/utils/constants.py b/dptb/utils/constants.py
index c571453b..277d958c 100644
--- a/dptb/utils/constants.py
+++ b/dptb/utils/constants.py
@@ -27,6 +27,32 @@
'p': ['py','pz','px'],
'd': ['dxy','dyz','dz2','dxz','dx2-y2']}
+ABACUS_orbital_number_m = {
+ "s": [0],
+ "p": [0, 1, -1],
+ "d": [0, 1, -1, 2, -2],
+ "f": [0, 1, -1, 2, -2, 3, -3]
+}
+
+DeePTB_orbital_number_m = {
+ "s": [0],
+ "p": [-1, 0, 1],
+ "d": [-2, -1, 0, 1, 2],
+ "f": [-3, -2, -1, 0, 1, 2, 3]
+}
+
+
+ABACUS2DeePTB = {
+ 0: torch.eye(1),
+ 1: torch.eye(3)[[2, 0, 1]],
+ 2: torch.eye(5)[[4, 2, 0, 1, 3]],
+ 3: torch.eye(7)[[6, 4, 2, 0, 1, 3, 5]]
+ }
+ABACUS2DeePTB[1][[0, 2]] *= -1
+ABACUS2DeePTB[2][[1, 3]] *= -1
+ABACUS2DeePTB[3][[0, 6, 2, 4]] *= -1
+
+
dtype_dict = {"float32": torch.float32, "float64": torch.float64}
# k = Boltzmann # k is the Boltzmann constant in old NEGF module
Coulomb = 6.24150974e18 # in the unit of eV*Angstrom
diff --git a/dptb/utils/index_mapping.py b/dptb/utils/index_mapping.py
index 0b1f0234..2dee58f6 100644
--- a/dptb/utils/index_mapping.py
+++ b/dptb/utils/index_mapping.py
@@ -1,9 +1,251 @@
from typing_extensions import Self
from dptb.utils.tools import get_uniq_symbol
-from dptb.utils.constants import anglrMId
+from dptb.utils.constants import anglrMId, atomic_num_dict
import re
+import torch
import numpy as np
+class Index_Mapings_e3(object):
+ def __init__(self, basis=None, method="e3tb"):
+ self.basis = basis
+ self.method = method
+ if basis is not None:
+ self.update(basis=basis)
+
+ if self.method not in ["e3tb", "sktb"]:
+ raise ValueError
+
+
+ def update(self, basis):
+ """_summary_
+
+ Parameters
+ ----------
+ basis : dict
+ the definition of the basis set, should be like:
+ {"A":"2s2p3d1f", "B":"1s2f3d1f"} or
+ {"A":["2s", "2p"], "B":["2s", "2p"]}
+ when list, "2s" indicate a "s" orbital in the second shell.
+ when str, "2s" indicates two s orbital,
+ "2s2p3d4f" is equivilent to ["1s","2s", "1p", "2p", "1d", "2d", "3d", "1f"]
+ """
+
+ self.atomtype = get_uniq_symbol(list(basis.keys())) # this will sort the atomtype according to the atomic number
+ self.atomtype_map = {at:i for i, at in enumerate(self.atomtype)}
+ self.bondtype = []
+
+ for it, at in enumerate(self.atomtype):
+ for jt, bt in enumerate(self.atomtype[it:]):
+ bond = at+"-"+bt
+ if bond not in at:
+ self.bondtype.append(bond)
+
+ self.bondtype_map = {bt:i for i, bt in enumerate(self.bondtype)}
+
+ # TODO: check the basis value
+
+ self.basis = basis
+ if isinstance(self.basis[self.atomtype[0]], str):
+ orbtype_count = {"s":0, "p":0, "d":0, "f":0}
+ orbs = map(lambda bs: re.findall(r'[1-9]+[A-Za-z]', bs), self.basis.values())
+ for ib in orbs:
+ for io in ib:
+ if int(io[0]) > orbtype_count[io[1]]:
+ orbtype_count[io[1]] = int(io[0])
+ # split into list basis
+ basis = {k:[] for k in self.atomtype}
+ for ib in self.basis.keys():
+ for io in ["s", "p", "d", "f"]:
+ if io in self.basis[ib]:
+ basis[ib].extend([str(i)+io for i in range(1, int(re.findall(r'[1-9]+'+io, self.basis[ib])[0][0])+1)])
+ self.basis = basis
+
+ elif isinstance(self.basis[self.atomtype[0]], list):
+ nb = len(self.atomtype)
+ orbtype_count = {"s":[0]*nb, "p":[0]*nb, "d":[0]*nb, "f":[0]*nb}
+ for ib, bt in enumerate(self.atomtype):
+ for io in self.basis[bt]:
+ orb = re.findall(r'[A-Za-z]', io)[0]
+ orbtype_count[orb][ib] += 1
+
+ for ko in orbtype_count.keys():
+ orbtype_count[ko] = max(orbtype_count[ko])
+
+ self.orbtype_count = orbtype_count
+
+ if self.method == "e3tb":
+ self.edge_reduced_matrix_element = (1 * orbtype_count["s"] + 3 * orbtype_count["p"] + 5 * orbtype_count["d"] + 7 * orbtype_count["f"]) **2
+ self.node_reduced_matrix_element = int(((orbtype_count["s"] + 9 * orbtype_count["p"] + 25 * orbtype_count["d"] + 49 * orbtype_count["f"]) + \
+ self.edge_reduced_matrix_element)/2)
+ else:
+ self.edge_reduced_matrix_element = 1 * (
+ 1 * orbtype_count["s"] * orbtype_count["s"] + \
+ 2 * orbtype_count["s"] * orbtype_count["p"] + \
+ 2 * orbtype_count["s"] * orbtype_count["d"] + \
+ 2 * orbtype_count["s"] * orbtype_count["f"]
+ ) + \
+ 2 * (
+ 1 * orbtype_count["p"] * orbtype_count["p"] + \
+ 2 * orbtype_count["p"] * orbtype_count["d"] + \
+ 2 * orbtype_count["p"] * orbtype_count["f"]
+ ) + \
+ 3 * (
+ 1 * orbtype_count["d"] * orbtype_count["d"] + \
+ 2 * orbtype_count["d"] * orbtype_count["f"]
+ ) + \
+ 4 * (orbtype_count["f"] * orbtype_count["f"])
+
+ self.node_reduced_matrix_element = orbtype_count["s"] + orbtype_count["p"] + orbtype_count["d"] + orbtype_count["f"]
+
+
+
+ # sort the basis
+ for ib in self.basis.keys():
+ self.basis[ib] = sorted(
+ self.basis[ib],
+ key=lambda s: (anglrMId[re.findall(r"[a-z]",s)[0]], re.findall(r"[1-9*]",s)[0])
+ )
+
+ # TODO: get full basis set
+ full_basis = []
+ for io in ["s", "p", "d", "f"]:
+ full_basis = full_basis + [str(i)+io for i in range(1, orbtype_count[io]+1)]
+ self.full_basis = full_basis
+
+ # TODO: get the mapping from list basis to full basis
+ self.basis_to_full_basis = {}
+ for ib in self.basis.keys():
+ count_dict = {"s":0, "p":0, "d":0, "f":0}
+ self.basis_to_full_basis.setdefault(ib, {})
+ for o in self.basis[ib]:
+ io = re.findall(r"[a-z]", o)[0]
+ count_dict[io] += 1
+ self.basis_to_full_basis[ib][o] = str(count_dict[io])+io
+
+ # also need to think if we modify as this, how can we add extra basis when fitting.
+
+
+ def get_pairtype_maps(self):
+ """
+ The function `get_pairtype_maps` creates a mapping of orbital pair types, such as s-s, "s-p",
+ to slices based on the number of hops between them.
+ :return: a dictionary called `pairtype_map`.
+ """
+
+ self.pairtype_maps = {}
+ ist = 0
+ for io in ["s", "p", "d", "f"]:
+ if self.orbtype_count[io] != 0:
+ for jo in ["s", "p", "d", "f"]:
+ if self.orbtype_count[jo] != 0:
+ orb_pair = io+"-"+jo
+ il, jl = anglrMId[io], anglrMId[jo]
+ if self.method == "e3tb":
+ n_rme = (2*il+1) * (2*jl+1)
+ else:
+ n_rme = min(il, jl)+1
+ numhops = self.orbtype_count[io] * self.orbtype_count[jo] * n_rme
+ self.pairtype_maps[orb_pair] = slice(ist, ist+numhops)
+
+ ist += numhops
+
+ return self.pairtype_maps
+
+ def get_pair_maps(self):
+
+ # here we have the map from basis to full basis, but to define a map between basis pair to full basis pair,
+ # one need to consider the id of the full basis pairs. Specifically, if we want to know the position where
+ # "s*-2s" lies, we map it to the pair in full basis as "1s-2s", but we need to know the id of "1s-2s" in the
+ # features vector. For a full basis have three s: [1s, 2s, 3s], it will have 9 s features. Therefore, we need
+ # to build a map from the full basis pair to the position in the vector.
+
+ # We define the feature vector should look like [1s-1s, 1s-2s, 1s-3s, 2s-1s, 2s-2s, 2s-3s, 3s-1s, 3s-2s, 3s-3s,...]
+ # it is sorted by the index of the left basis first, then the right basis. Therefore, we can build a map:
+
+ # to do so we need the pair type maps first
+ if not hasattr(self, "pairtype_maps"):
+ self.pairtype_maps = self.get_pairtype_maps()
+ self.pair_maps = {}
+ for ib in self.bondtype:
+ ia, ja = ib.split("-")
+ self.pair_maps.setdefault(ib, {})
+ for io in self.basis[ia]:
+ for jo in self.basis[ja]:
+ full_basis_pair = self.basis_to_full_basis[ia][io]+"-"+self.basis_to_full_basis[ja][jo]
+ ir, jr = int(full_basis_pair[0]), int(full_basis_pair[3])
+ iio, jjo = full_basis_pair[1], full_basis_pair[4]
+
+ if self.method == "e3tb":
+ n_feature = (2*anglrMId[iio]+1) * (2*anglrMId[jjo]+1)
+ else:
+ n_feature = min(anglrMId[iio], anglrMId[jjo])+1
+
+
+ start = self.pairtype_maps[iio+"-"+jjo].start + \
+ n_feature * ((ir-1)*self.orbtype_count[jjo]+(jr-1))
+
+ self.pair_maps[ib][io+"-"+jo] = slice(start, start+n_feature)
+
+
+ return self.pair_maps
+
+ def get_node_maps(self):
+ if not hasattr(self, "nodetype_maps"):
+ self.get_nodetype_maps()
+
+ self.node_maps = {}
+ for at in self.atomtype:
+ self.node_maps.setdefault(at, {})
+ for i, io in enumerate(self.basis[at]):
+ for jo in self.basis[at][i:]:
+ full_basis_pair = self.basis_to_full_basis[at][io]+"-"+self.basis_to_full_basis[at][jo]
+ ir, jr = int(full_basis_pair[0]), int(full_basis_pair[3])
+ iio, jjo = full_basis_pair[1], full_basis_pair[4]
+
+ if self.method == "e3tb":
+ n_feature = (2*anglrMId[iio]+1) * (2*anglrMId[jjo]+1)
+ else:
+ if io == jo:
+ n_feature = 1
+ else:
+ n_feature = 0
+
+ start = self.nodetype_maps[iio+"-"+jjo].start + \
+ n_feature * (2*self.orbtype_count[jjo]+1-ir) * (ir-1) / 2 + (jr - 1)
+ start = int(start)
+
+ self.node_maps[at][io+"-"+jo] = slice(start, start+n_feature)
+
+ return self.node_maps
+
+ def get_nodetype_maps(self):
+ self.nodetype_maps = {}
+ ist = 0
+
+ for i, io in enumerate(["s", "p", "d", "f"]):
+ if self.orbtype_count[io] != 0:
+ for jo in ["s", "p", "d", "f"][i:]:
+ if self.orbtype_count[jo] != 0:
+ orb_pair = io+"-"+jo
+ il, jl = anglrMId[io], anglrMId[jo]
+ if self.method == "e3tb":
+ numonsites = self.orbtype_count[io] * self.orbtype_count[jo] * (2*il+1) * (2*jl+1)
+ if io == jo:
+ numonsites += self.orbtype_count[jo] * (2*il+1) * (2*jl+1)
+ numonsites = int(numonsites / 2)
+ else:
+ if io == jo:
+ numonsites = self.orbtype_count[io]
+ else:
+ numonsites = 0
+
+ self.nodetype_maps[orb_pair] = slice(ist, ist+numonsites)
+
+ ist += numonsites
+
+
+ return self.nodetype_maps
+
class Index_Mapings(object):
''' creat index mappings for networks outs and the corresponding physical parameters.
diff --git a/dptb/utils/multiprocessing.py b/dptb/utils/multiprocessing.py
new file mode 100644
index 00000000..3b28b06a
--- /dev/null
+++ b/dptb/utils/multiprocessing.py
@@ -0,0 +1,24 @@
+import os
+
+_has_sched_getaffinity: bool = hasattr(os, "sched_getaffinity")
+
+
+def num_tasks() -> int:
+ # sched_getaffinity gives number of _allowed_ cores
+ # this is correct for SLURM jobs, for example
+ num_avail: int
+ if _has_sched_getaffinity:
+ num_avail = len(os.sched_getaffinity(0))
+ else:
+ # on macOS, at least, sched_getaffinity() doesn't appear to be available.
+ # fallback to something sane
+ num_avail = os.cpu_count()
+ # If we couldn't get affinity, don't default to the whole system... sane default to 1
+ n_proc: int = int(
+ os.environ.get("NEQUIP_NUM_TASKS", num_avail if _has_sched_getaffinity else 1)
+ )
+ assert n_proc > 0
+ assert (
+ n_proc <= num_avail
+ ), f"Asked for more worker tasks NEQUIP_NUM_TASKS={n_proc} than available CPU cores {num_avail}"
+ return n_proc
diff --git a/dptb/utils/register.py b/dptb/utils/register.py
new file mode 100644
index 00000000..3dced832
--- /dev/null
+++ b/dptb/utils/register.py
@@ -0,0 +1,41 @@
+
+class Register(dict):
+ def __init__(self, *args, **kwargs):
+ super(Register, self).__init__(*args, **kwargs)
+ self._dict = {}
+
+ def register(self, target):
+
+ def add_register_item(key, value):
+ if not callable(value):
+ raise Exception(f"register object must be callable! But receice:{value} is not callable!")
+ if key in self._dict:
+ print(f"warning: \033[33m{value.__name__} has been registered before, so we will overriden it\033[0m")
+ self[key] = value
+ return value
+
+ if callable(target):
+ return add_register_item(target.__name__, target)
+ else:
+ return lambda x : add_register_item(target, x)
+
+ def __setitem__(self, key, value):
+ self._dict[key] = value
+
+ def __getitem__(self, key):
+ return self._dict[key]
+
+ def __contains__(self, key):
+ return key in self._dict
+
+ def __str__(self):
+ return str(self._dict)
+
+ def keys(self):
+ return self._dict.keys()
+
+ def values(self):
+ return self._dict.values()
+
+ def items(self):
+ return self._dict.items()
\ No newline at end of file
diff --git a/dptb/utils/regressor.py b/dptb/utils/regressor.py
new file mode 100644
index 00000000..578c45f6
--- /dev/null
+++ b/dptb/utils/regressor.py
@@ -0,0 +1,82 @@
+import logging
+import torch
+
+from torch import matmul
+from typing import Optional, Sequence
+from opt_einsum import contract
+
+
+def solver(X, y, alpha: Optional[float] = 0.001, stride: Optional[int] = 1, **kwargs):
+ # results are in the same "units" as y, so same dtype too:
+ dtype_out = y.dtype
+ # always solve in float64 for numerical stability
+ dtype = torch.float64
+ X = X[::stride].to(dtype)
+ y = y[::stride].to(dtype)
+
+ X, y = down_sampling_by_composition(X, y)
+
+ X_norm = torch.sum(X)
+
+ X = X / X_norm
+ y = y / X_norm
+
+ y_mean = torch.sum(y) / torch.sum(X)
+
+ feature_rms = torch.sqrt(torch.mean(X**2, axis=0))
+
+ alpha_mat = torch.diag(feature_rms) * (alpha * alpha)
+
+ A = matmul(X.T, X) + alpha_mat
+ dy = y - (torch.sum(X, axis=1, keepdim=True) * y_mean).reshape(y.shape)
+ Xy = matmul(X.T, dy)
+
+ # A is symmetric positive semidefinite <=> A=(X + alpha*I)^T (X + alpha*I),
+ # so we can use cholesky:
+ A_cholesky = torch.linalg.cholesky(A)
+ mean = torch.cholesky_solve(Xy.unsqueeze(-1), A_cholesky).squeeze(-1)
+ Ainv = torch.cholesky_inverse(A_cholesky)
+ del A_cholesky
+
+ sigma2 = torch.var(matmul(X, mean) - dy)
+ cov = torch.sqrt(sigma2 * contract("ij,kj,kl,li->i", Ainv, X, X, Ainv))
+
+ mean = mean + y_mean.reshape([-1])
+
+ logging.debug(f"Ridge Regression, residue {sigma2}")
+
+ return mean.to(dtype_out), cov.to(dtype_out)
+
+
+def down_sampling_by_composition(
+ X: torch.Tensor, y: torch.Tensor, percentage: Sequence = [0.25, 0.5, 0.75]
+):
+
+ unique_comps, comp_ids = torch.unique(X, dim=0, return_inverse=True)
+
+ n_types = torch.max(comp_ids) + 1
+
+ sort_by = torch.argsort(comp_ids)
+
+ # find out the block for each composition
+ d_icomp = comp_ids[sort_by]
+ d_icomp = d_icomp[:-1] - d_icomp[1:]
+ node_icomp = torch.where(d_icomp != 0)[0]
+ id_start = torch.cat((torch.as_tensor([0]), node_icomp + 1))
+ id_end = torch.cat((node_icomp + 1, torch.as_tensor([len(sort_by)])))
+
+ n_points = len(percentage)
+ new_X = torch.zeros(
+ (n_types * n_points, X.shape[1]), dtype=X.dtype, device=X.device
+ )
+ new_y = torch.zeros((n_types * n_points), dtype=y.dtype, device=y.device)
+ for i in range(n_types):
+ ids = sort_by[id_start[i] : id_end[i]]
+ for j, p in enumerate(percentage):
+ # it defaults to linear anyway, and `interpolation` was a 1.11 addition
+ # so we leave out `, interpolation="linear")`
+ # https://pytorch.org/docs/1.11/generated/torch.quantile.html?highlight=quantile#torch.quantile
+ new_y[i * n_points + j] = torch.quantile(y[ids], p)
+ new_X[i * n_points + j] = unique_comps[i]
+
+ return new_X, new_y
diff --git a/dptb/utils/savenload.py b/dptb/utils/savenload.py
new file mode 100644
index 00000000..53b09fcf
--- /dev/null
+++ b/dptb/utils/savenload.py
@@ -0,0 +1,376 @@
+"""
+utilities that involve file searching and operations (i.e. save/load)
+"""
+from typing import Union, List, Tuple, Optional, Callable
+import sys
+import logging
+import contextlib
+import contextvars
+import tempfile
+from pathlib import Path
+import shutil
+import os
+import yaml
+
+
+# accumulate writes to group for renaming
+_MOVE_SET = contextvars.ContextVar("_move_set", default=None)
+
+
+def _delete_files_if_exist(paths):
+ # clean up
+ # better for python 3.8 >
+ if sys.version_info[1] >= 8:
+ for f in paths:
+ f.unlink(missing_ok=True)
+ else:
+ # race condition?
+ for f in paths:
+ if f.exists():
+ f.unlink()
+
+
+def _process_moves(moves: List[Tuple[bool, Path, Path]]):
+ """blocking to copy (possibly across filesystems) to temp name; then atomic rename to final name"""
+ try:
+ for _, from_name, to_name in moves:
+ # blocking copy to temp file in same filesystem
+ tmp_path = to_name.parent / (f".tmp-{to_name.name}~")
+ shutil.move(from_name, tmp_path)
+ # then atomic rename to overwrite
+ tmp_path.rename(to_name)
+ finally:
+ _delete_files_if_exist([m[1] for m in moves])
+
+
+# allow user to enable/disable depending on their filesystem
+_ASYNC_ENABLED = os.environ.get("NEQUIP_ASYNC_IO", "false").lower()
+assert _ASYNC_ENABLED in ("true", "false")
+_ASYNC_ENABLED = _ASYNC_ENABLED == "true"
+
+if _ASYNC_ENABLED:
+ import threading
+ from queue import Queue
+
+ _MOVE_QUEUE = Queue()
+ _MOVE_THREAD = None
+
+ # Because we use a queue, later writes will always (correctly)
+ # overwrite earlier writes
+ def _moving_thread(queue):
+ while True:
+ moves = queue.get()
+ _process_moves(moves)
+ # logging is thread safe: https://stackoverflow.com/questions/2973900/is-pythons-logging-module-thread-safe
+ logging.debug(f"Finished writing {', '.join(m[2].name for m in moves)}")
+ queue.task_done()
+
+ def _submit_move(from_name, to_name, blocking: bool):
+ global _MOVE_QUEUE
+ global _MOVE_THREAD
+ global _MOVE_SET
+
+ # launch thread if its not running
+ if _MOVE_THREAD is None:
+ _MOVE_THREAD = threading.Thread(
+ target=_moving_thread, args=(_MOVE_QUEUE,), daemon=True
+ )
+ _MOVE_THREAD.start()
+
+ # check on health of copier thread
+ if not _MOVE_THREAD.is_alive():
+ _MOVE_THREAD.join() # will raise exception
+ raise RuntimeError("Writer thread failed.")
+
+ # submit this move
+ obj = (blocking, from_name, to_name)
+ if _MOVE_SET.get() is None:
+ # no current group
+ _MOVE_QUEUE.put([obj])
+ # if it should be blocking, wait for it to be processed
+ if blocking:
+ _MOVE_QUEUE.join()
+ else:
+ # add and let the group submit and block (or not)
+ _MOVE_SET.get().append(obj)
+
+ @contextlib.contextmanager
+ def atomic_write_group():
+ global _MOVE_SET
+ if _MOVE_SET.get() is not None:
+ # nesting is a no-op
+ # submit along with outermost context manager
+ yield
+ return
+ token = _MOVE_SET.set(list())
+ # run the saves
+ yield
+ _MOVE_QUEUE.put(_MOVE_SET.get()) # send it off
+ # if anyone is blocking, block the whole group:
+ if any(m[0] for m in _MOVE_SET.get()):
+ # someone is blocking
+ _MOVE_QUEUE.join()
+ # exit context
+ _MOVE_SET.reset(token)
+
+ def finish_all_writes():
+ global _MOVE_QUEUE
+ _MOVE_QUEUE.join()
+ # ^ wait for all remaining moves to be processed
+
+else:
+
+ def _submit_move(from_name, to_name, blocking: bool):
+ global _MOVE_SET
+ obj = (blocking, from_name, to_name)
+ if _MOVE_SET.get() is None:
+ # no current group just do it
+ _process_moves([obj])
+ else:
+ # add and let the group do it
+ _MOVE_SET.get().append(obj)
+
+ @contextlib.contextmanager
+ def atomic_write_group():
+ global _MOVE_SET
+ if _MOVE_SET.get() is not None:
+ # don't nest them
+ yield
+ return
+ token = _MOVE_SET.set(list())
+ yield
+ _process_moves(_MOVE_SET.get()) # do it
+ _MOVE_SET.reset(token)
+
+ def finish_all_writes():
+ pass # nothing to do since all writes blocked
+
+
+@contextlib.contextmanager
+def atomic_write(
+ filename: Union[Path, str, List[Union[Path, str]]],
+ blocking: bool = True,
+ binary: bool = False,
+):
+ aslist: bool = True
+ if not isinstance(filename, list):
+ aslist = False
+ filename = [filename]
+ filename = [Path(f) for f in filename]
+
+ with contextlib.ExitStack() as stack:
+ files = [
+ stack.enter_context(
+ tempfile.NamedTemporaryFile(
+ mode="w" + ("b" if binary else ""), delete=False
+ )
+ )
+ for _ in filename
+ ]
+ try:
+ if not aslist:
+ yield files[0]
+ else:
+ yield files
+ except: # noqa
+ # ^ noqa cause we want to delete them no matter what if there was a failure
+ # only remove them if there was an error
+ _delete_files_if_exist([Path(f.name) for f in files])
+ raise
+
+ for tp, fname in zip(files, filename):
+ _submit_move(Path(tp.name), Path(fname), blocking=blocking)
+
+
+def save_file(
+ item,
+ supported_formats: dict,
+ filename: str,
+ enforced_format: str = None,
+ blocking: bool = True,
+):
+ """
+ Save file. It can take yaml, json, pickle, json, npz and torch save
+ """
+
+ # check whether folder exist
+ path = os.path.dirname(os.path.realpath(filename))
+ if not os.path.isdir(path):
+ logging.debug(f"save_file make dirs {path}")
+ os.makedirs(path, exist_ok=True)
+
+ format, filename = adjust_format_name(
+ supported_formats=supported_formats,
+ filename=filename,
+ enforced_format=enforced_format,
+ )
+
+ with atomic_write(
+ filename,
+ blocking=blocking,
+ binary={
+ "json": False,
+ "yaml": False,
+ "pickle": True,
+ "torch": True,
+ "npz": True,
+ }[format],
+ ) as write_to:
+ if format == "json":
+ import json
+
+ json.dump(item, write_to)
+ elif format == "yaml":
+ import yaml
+
+ yaml.dump(item, write_to)
+ elif format == "torch":
+ import torch
+
+ torch.save(item, write_to)
+ elif format == "pickle":
+ import pickle
+
+ pickle.dump(item, write_to)
+ elif format == "npz":
+ import numpy as np
+
+ np.savez(write_to, item)
+ else:
+ raise NotImplementedError(
+ f"Output format {format} not supported:"
+ f" try from {supported_formats.keys()}"
+ )
+
+ return filename
+
+
+def load_file(supported_formats: dict, filename: str, enforced_format: str = None):
+ """
+ Load file. Current support form
+ """
+ if enforced_format is None:
+ format = match_suffix(supported_formats=supported_formats, filename=filename)
+ else:
+ format = enforced_format
+
+ if not os.path.isfile(filename):
+ abs_path = str(Path(filename).resolve())
+ raise OSError(f"file {filename} at {abs_path} is not found")
+
+ if format == "json":
+ import json
+
+ with open(filename) as fin:
+ return json.load(fin)
+ elif format == "yaml":
+ import yaml
+
+ with open(filename) as fin:
+ return yaml.load(fin, Loader=yaml.Loader)
+ elif format == "torch":
+ import torch
+
+ return torch.load(filename)
+ elif format == "pickle":
+ import pickle
+
+ with open(filename, "rb") as fin:
+ return pickle.load(fin)
+ elif format == "npz":
+ import numpy as np
+
+ return np.load(filename, allow_pickle=True)
+ else:
+ raise NotImplementedError(
+ f"Input format not supported:" f" try from {supported_formats.keys()}"
+ )
+
+
+def load_callable(obj: Union[str, Callable], prefix: Optional[str] = None) -> Callable:
+ """Load a callable from a name, or pass through a callable."""
+ if callable(obj):
+ pass
+ elif isinstance(obj, str):
+ if "." not in obj:
+ # It's an unqualified name
+ if prefix is not None:
+ obj = prefix + "." + obj
+ else:
+ # You can't have an unqualified name without a prefix
+ raise ValueError(f"Cannot load unqualified name {obj}.")
+ obj = yaml.load(f"!!python/name:{obj}", Loader=yaml.Loader)
+ else:
+ raise TypeError
+ assert callable(obj), f"{obj} isn't callable"
+ return obj
+
+
+def adjust_format_name(
+ supported_formats: dict, filename: str, enforced_format: str = None
+):
+ """
+ Recognize whether proper suffix is added to the filename.
+ If not, add it and return the formatted file name
+
+ Args:
+
+ supported_formats (dict): list of supported formats and corresponding suffix
+ filename (str): initial filename
+ enforced_format (str): default format
+
+ Returns:
+
+ newformat (str): the chosen format
+ newname (str): the adjusted filename
+
+ """
+ if enforced_format is None:
+ newformat = match_suffix(supported_formats=supported_formats, filename=filename)
+ else:
+ newformat = enforced_format
+
+ newname = f"{filename}"
+
+ add_suffix = True
+ suffix = supported_formats[newformat]
+
+ if not isinstance(suffix, (set, list, tuple)):
+ suffix = [suffix]
+
+ if len(suffix) > 0:
+ for suf in suffix:
+ if filename.endswith(f".{suf}"):
+ add_suffix = False
+
+ if add_suffix:
+ suffix = suffix[0]
+ newname += f".{suffix}"
+
+ return newformat, newname
+
+
+def match_suffix(supported_formats: str, filename: str):
+ """
+ Recognize format based on suffix
+
+ Args:
+
+ supported_formats (dict): list of supported formats and corresponding suffix
+ filename (str): initial filename
+
+ Returns:
+
+ format (str): the recognized format
+
+ """
+ for form, suffs in supported_formats.items():
+ if isinstance(suffs, (set, list, tuple)):
+ for suff in suffs:
+ if filename.lower().endswith(f".{suff}"):
+ return form
+ else:
+ if filename.lower().endswith(f".{suffs}"):
+ return form
+
+ return list(supported_formats.keys())[0]
diff --git a/dptb/utils/tools.py b/dptb/utils/tools.py
index 1f41612f..2dc1f370 100644
--- a/dptb/utils/tools.py
+++ b/dptb/utils/tools.py
@@ -4,7 +4,6 @@
import torch
import torch.nn.functional as F
from dptb.utils.constants import atomic_num_dict, anglrMId, SKBondType
-from dptb.nnsktb.onsiteDB import onsite_energy_database
from typing import (
TYPE_CHECKING,
Any,
@@ -17,7 +16,6 @@
Union,
)
import json
-from dptb.nnsktb.formula import SKFormula
from pathlib import Path
import yaml
import torch.optim as optim
@@ -26,6 +24,11 @@
from ase.neighborlist import neighbor_list
from ase.io.trajectory import Trajectory
import ase
+import ssl
+import os.path as osp
+import urllib
+import zipfile
+import sys
log = logging.getLogger(__name__)
@@ -137,8 +140,10 @@ def get_lr_scheduler(type: str, optimizer: optim.Optimizer, **sch_options):
scheduler = optim.lr_scheduler.ExponentialLR(optimizer=optimizer, **sch_options)
elif type == 'linear':
scheduler = optim.lr_scheduler.LinearLR(optimizer=optimizer, **sch_options)
+ elif type == "rop":
+ scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, **sch_options)
else:
- raise RuntimeError("Scheduler should be exp/linear/..., not {}".format(type))
+ raise RuntimeError("Scheduler should be exp/linear/rop..., not {}".format(type))
return scheduler
@@ -174,6 +179,8 @@ def _get_activation_fn(activation):
return F.gelu
elif activation == "tanh":
return torch.tanh
+ elif activation == "silu":
+ return torch.nn.SiLU()
raise RuntimeError("activation should be relu/gelu/tanh, not {}".format(activation))
@@ -706,7 +713,53 @@ def bn_stast(traj_path: str, cutoff: float =10., nns=[3.0, 4.5], first=False, re
return stast
+def makedirs(dir):
+ os.makedirs(dir, exist_ok=True)
+def download_url(url, folder, log=True):
+ r"""Downloads the content of an URL to a specific folder.
+
+ Args:
+ url (string): The url.
+ folder (string): The folder.
+ log (bool, optional): If :obj:`False`, will not print anything to the
+ console. (default: :obj:`True`)
+ """
+
+ filename = url.rpartition("/")[2].split("?")[0]
+ path = osp.join(folder, filename)
+
+ if osp.exists(path): # pragma: no cover
+ if log:
+ print("Using existing file", filename, file=sys.stderr)
+ return path
+
+ if log:
+ print("Downloading", url, file=sys.stderr)
+
+ makedirs(folder)
+
+ context = ssl._create_unverified_context()
+ data = urllib.request.urlopen(url, context=context)
+
+ with open(path, "wb") as f:
+ f.write(data.read())
+
+ return path
+
+
+def extract_zip(path, folder, log=True):
+ r"""Extracts a zip archive to a specific folder.
+
+ Args:
+ path (string): The path to the tar archive.
+ folder (string): The folder.
+ log (bool, optional): If :obj:`False`, will not print anything to the
+ console. (default: :obj:`True`)
+ """
+ with zipfile.ZipFile(path, "r") as f:
+ f.extractall(folder)
+
if __name__ == '__main__':
print(get_neuron_config(nl=[0,1,2,3,4,5,6,7]))
diff --git a/dptb/utils/torch_geometric/README.md b/dptb/utils/torch_geometric/README.md
new file mode 100644
index 00000000..353d1901
--- /dev/null
+++ b/dptb/utils/torch_geometric/README.md
@@ -0,0 +1,10 @@
+# Trimmed-down `pytorch_geometric`
+
+NequIP uses the data format and code of the excellent [`pytorch_geometric`](https://pytorch-geometric.readthedocs.io/en/latest/) [1, 2] framework. We use, however, only a very limited subset of that library: the most basic graph data structures.
+
+To avoid adding a large number of unnecessary second-degree dependencies, and to simplify installation, we include and modify here the small subset of `torch_geometric` that is neccessary for our code.
+
+We are grateful to the developers of PyTorch Geometric for their ongoing and very useful work on graph learning with PyTorch.
+
+ [1] Fey, M., & Lenssen, J. E. (2019). Fast Graph Representation Learning with PyTorch Geometric (Version 2.0.1) [Computer software]. https://github.com/pyg-team/pytorch_geometric
+ [2] https://arxiv.org/abs/1903.02428
\ No newline at end of file
diff --git a/dptb/utils/torch_geometric/__init__.py b/dptb/utils/torch_geometric/__init__.py
new file mode 100644
index 00000000..818ea494
--- /dev/null
+++ b/dptb/utils/torch_geometric/__init__.py
@@ -0,0 +1,5 @@
+from .batch import Batch
+from .data import Data
+from .dataset import Dataset
+
+__all__ = ["Batch", "Data", "Dataset"]
diff --git a/dptb/utils/torch_geometric/batch.py b/dptb/utils/torch_geometric/batch.py
new file mode 100644
index 00000000..f03bb517
--- /dev/null
+++ b/dptb/utils/torch_geometric/batch.py
@@ -0,0 +1,273 @@
+from typing import List
+
+from collections.abc import Sequence
+
+import torch
+import numpy as np
+from torch import Tensor
+
+from .data import Data
+from .dataset import IndexType
+
+## Comment from Zhanghao Z.Y.
+# prexist Comment
+
+class Batch(Data):
+ r"""A plain old python object modeling a batch of graphs as one big
+ (disconnected) graph. With :class:`torch_geometric.data.Data` being the
+ base class, all its methods can also be used here.
+ In addition, single graphs can be reconstructed via the assignment vector
+ :obj:`batch`, which maps each node to its respective graph identifier.
+ """
+
+ def __init__(self, batch=None, ptr=None, **kwargs):
+ super(Batch, self).__init__(**kwargs)
+
+ for key, item in kwargs.items():
+ if key == "num_nodes":
+ self.__num_nodes__ = item
+ else:
+ self[key] = item
+
+ self.batch = batch
+ self.ptr = ptr
+ self.__data_class__ = Data
+ self.__slices__ = None
+ self.__cumsum__ = None
+ self.__cat_dims__ = None
+ self.__num_nodes_list__ = None
+ self.__num_graphs__ = None
+
+ @classmethod
+ def from_data_list(cls, data_list, follow_batch=[], exclude_keys=[]):
+ r"""Constructs a batch object from a python list holding
+ :class:`torch_geometric.data.Data` objects.
+ The assignment vector :obj:`batch` is created on the fly.
+ Additionally, creates assignment batch vectors for each key in
+ :obj:`follow_batch`.
+ Will exclude any keys given in :obj:`exclude_keys`."""
+
+ keys = list(set(data_list[0].keys) - set(exclude_keys))
+ assert "batch" not in keys and "ptr" not in keys
+
+ batch = cls()
+ for key in data_list[0].__dict__.keys():
+ if key[:2] != "__" and key[-2:] != "__":
+ batch[key] = None
+
+ batch.__num_graphs__ = len(data_list)
+ batch.__data_class__ = data_list[0].__class__
+ for key in keys + ["batch"]:
+ batch[key] = []
+ batch["ptr"] = [0]
+
+ device = None
+ slices = {key: [0] for key in keys}
+ cumsum = {key: [0] for key in keys}
+ cat_dims = {}
+ num_nodes_list = []
+ for i, data in enumerate(data_list):
+ for key in keys:
+ item = data[key]
+
+ # Increase values by `cumsum` value.
+ cum = cumsum[key][-1]
+ if isinstance(item, Tensor) and item.dtype != torch.bool:
+ if not isinstance(cum, int) or cum != 0:
+ item = item + cum
+ elif isinstance(item, (int, float)):
+ item = item + cum
+
+ # Gather the size of the `cat` dimension.
+ size = 1
+ cat_dim = data.__cat_dim__(key, data[key])
+ # 0-dimensional tensors have no dimension along which to
+ # concatenate, so we set `cat_dim` to `None`.
+ if isinstance(item, Tensor) and item.dim() == 0: ## which means this tensor is a scalar
+ cat_dim = None
+ cat_dims[key] = cat_dim
+
+ # Add a batch dimension to items whose `cat_dim` is `None`:
+ if isinstance(item, Tensor) and cat_dim is None:
+ cat_dim = 0 # Concatenate along this new batch dimension.
+ item = item.unsqueeze(0)
+ device = item.device
+ elif isinstance(item, Tensor): ## cat_dim is not none
+ size = item.size(cat_dim)
+ device = item.device
+
+ if getattr(item, 'is_nested', False):
+ assert cat_dim == 0, "The batch collection of nested data only support concatenation on 0 dimension"
+ item = item.unbind()
+ batch[key] += item
+ else:
+ batch[key].append(item) # Append item to the attribute list.
+
+ slices[key].append(size + slices[key][-1])
+ inc = data.__inc__(key, item)
+ if isinstance(inc, (tuple, list)):
+ inc = torch.tensor(inc)
+ cumsum[key].append(inc + cumsum[key][-1])
+
+ if key in follow_batch: ## follow batch is not used in dataloader
+ if isinstance(size, Tensor):
+ for j, size in enumerate(size.tolist()):
+ tmp = f"{key}_{j}_batch"
+ batch[tmp] = [] if i == 0 else batch[tmp]
+ batch[tmp].append(
+ torch.full((size,), i, dtype=torch.long, device=device)
+ )
+ else:
+ tmp = f"{key}_batch"
+ batch[tmp] = [] if i == 0 else batch[tmp]
+ batch[tmp].append(
+ torch.full((size,), i, dtype=torch.long, device=device)
+ )
+
+ if hasattr(data, "__num_nodes__"):
+ num_nodes_list.append(data.__num_nodes__)
+ else:
+ num_nodes_list.append(None)
+
+ num_nodes = data.num_nodes
+ if num_nodes is not None:
+ item = torch.full((num_nodes,), i, dtype=torch.long, device=device)
+ batch.batch.append(item)
+ batch.ptr.append(batch.ptr[-1] + num_nodes)
+
+ batch.batch = None if len(batch.batch) == 0 else batch.batch
+ batch.ptr = None if len(batch.ptr) == 1 else batch.ptr
+ batch.__slices__ = slices
+ batch.__cumsum__ = cumsum
+ batch.__cat_dims__ = cat_dims
+ batch.__num_nodes_list__ = num_nodes_list
+
+ ref_data = data_list[0]
+ for key in batch.keys:
+ items = batch[key]
+ if None in items:
+ raise ValueError(
+ f"Found a `None` in the provided data objects for batching in key `{key}`"
+ )
+ item = items[0]
+ cat_dim = ref_data.__cat_dim__(key, item)
+ cat_dim = 0 if cat_dim is None else cat_dim
+ if isinstance(item, Tensor):
+ if getattr(data_list[0][key], "is_nested", False):
+ batch[key] = torch.nest.nested_tensor(items) ## concat into a nested tensor
+ else:
+ batch[key] = torch.cat(items, cat_dim) ## cat data according to the cat dim
+
+ elif isinstance(item, (int, float)):
+ batch[key] = torch.tensor(items)
+
+ # if torch_geometric.is_debug_enabled():
+ # batch.debug()
+
+ return batch.contiguous()
+
+ def get_example(self, idx: int) -> Data:
+ r"""Reconstructs the :class:`torch_geometric.data.Data` object at index
+ :obj:`idx` from the batch object.
+ The batch object must have been created via :meth:`from_data_list` in
+ order to be able to reconstruct the initial objects."""
+
+ if self.__slices__ is None:
+ raise RuntimeError(
+ (
+ "Cannot reconstruct data list from batch because the batch "
+ "object was not created using `Batch.from_data_list()`."
+ )
+ )
+
+ data = self.__data_class__()
+ idx = self.num_graphs + idx if idx < 0 else idx
+
+ for key in self.__slices__.keys():
+ item = self[key]
+ if self.__cat_dims__[key] is None:
+ # The item was concatenated along a new batch dimension,
+ # so just index in that dimension:
+ item = item[idx]
+ else:
+ # Narrow the item based on the values in `__slices__`.
+ if isinstance(item, Tensor):
+ dim = self.__cat_dims__[key]
+ start = self.__slices__[key][idx]
+ end = self.__slices__[key][idx + 1]
+ item = item.narrow(dim, start, end - start)
+ else:
+ start = self.__slices__[key][idx]
+ end = self.__slices__[key][idx + 1]
+ item = item[start:end]
+ item = item[0] if len(item) == 1 else item
+
+ # Decrease its value by `cumsum` value:
+ cum = self.__cumsum__[key][idx]
+ if isinstance(item, Tensor):
+ if not isinstance(cum, int) or cum != 0:
+ item = item - cum
+ elif isinstance(item, (int, float)):
+ item = item - cum
+
+ data[key] = item
+
+ if self.__num_nodes_list__[idx] is not None:
+ data.num_nodes = self.__num_nodes_list__[idx]
+
+ return data
+
+ def index_select(self, idx: IndexType) -> List[Data]:
+ if isinstance(idx, slice):
+ idx = list(range(self.num_graphs)[idx])
+
+ elif isinstance(idx, Tensor) and idx.dtype == torch.long:
+ idx = idx.flatten().tolist()
+
+ elif isinstance(idx, Tensor) and idx.dtype == torch.bool:
+ idx = idx.flatten().nonzero(as_tuple=False).flatten().tolist()
+
+ elif isinstance(idx, np.ndarray) and idx.dtype == np.int64:
+ idx = idx.flatten().tolist()
+
+ elif isinstance(idx, np.ndarray) and idx.dtype == np.bool:
+ idx = idx.flatten().nonzero()[0].flatten().tolist()
+
+ elif isinstance(idx, Sequence) and not isinstance(idx, str):
+ pass
+
+ else:
+ raise IndexError(
+ f"Only integers, slices (':'), list, tuples, torch.tensor and "
+ f"np.ndarray of dtype long or bool are valid indices (got "
+ f"'{type(idx).__name__}')"
+ )
+
+ return [self.get_example(i) for i in idx]
+
+ def __getitem__(self, idx):
+ if isinstance(idx, str):
+ return super(Batch, self).__getitem__(idx)
+ elif isinstance(idx, (int, np.integer)):
+ return self.get_example(idx)
+ else:
+ return self.index_select(idx)
+
+ def to_data_list(self) -> List[Data]:
+ r"""Reconstructs the list of :class:`torch_geometric.data.Data` objects
+ from the batch object.
+ The batch object must have been created via :meth:`from_data_list` in
+ order to be able to reconstruct the initial objects."""
+ return [self.get_example(i) for i in range(self.num_graphs)]
+
+ @property
+ def num_graphs(self) -> int:
+ """Returns the number of graphs in the batch."""
+ if self.__num_graphs__ is not None:
+ return self.__num_graphs__
+ elif self.ptr is not None:
+ return self.ptr.numel() - 1
+ elif self.batch is not None:
+ return int(self.batch.max()) + 1
+ else:
+ raise ValueError
diff --git a/dptb/utils/torch_geometric/data.py b/dptb/utils/torch_geometric/data.py
new file mode 100644
index 00000000..3b737f49
--- /dev/null
+++ b/dptb/utils/torch_geometric/data.py
@@ -0,0 +1,441 @@
+import re
+import copy
+import collections
+
+import torch
+
+# from ..utils.num_nodes import maybe_num_nodes
+
+__num_nodes_warn_msg__ = (
+ "The number of nodes in your data object can only be inferred by its {} "
+ "indices, and hence may result in unexpected batch-wise behavior, e.g., "
+ "in case there exists isolated nodes. Please consider explicitly setting "
+ "the number of nodes for this data object by assigning it to "
+ "data.num_nodes."
+)
+
+
+def size_repr(key, item, indent=0):
+ indent_str = " " * indent
+ if torch.is_tensor(item) and item.dim() == 0:
+ out = item.item()
+ elif torch.is_tensor(item):
+ out = str(list(item.size()))
+ elif isinstance(item, list) or isinstance(item, tuple):
+ out = str([len(item)])
+ elif isinstance(item, dict):
+ lines = [indent_str + size_repr(k, v, 2) for k, v in item.items()]
+ out = "{\n" + ",\n".join(lines) + "\n" + indent_str + "}"
+ elif isinstance(item, str):
+ out = f'"{item}"'
+ else:
+ out = str(item)
+
+ return f"{indent_str}{key}={out}"
+
+
+class Data(object):
+ r"""A plain old python object modeling a single graph with various
+ (optional) attributes:
+
+ Args:
+ x (Tensor, optional): Node feature matrix with shape :obj:`[num_nodes,
+ num_node_features]`. (default: :obj:`None`)
+ edge_index (LongTensor, optional): Graph connectivity in COO format
+ with shape :obj:`[2, num_edges]`. (default: :obj:`None`)
+ edge_attr (Tensor, optional): Edge feature matrix with shape
+ :obj:`[num_edges, num_edge_features]`. (default: :obj:`None`)
+ y (Tensor, optional): Graph or node targets with arbitrary shape.
+ (default: :obj:`None`)
+ pos (Tensor, optional): Node position matrix with shape
+ :obj:`[num_nodes, num_dimensions]`. (default: :obj:`None`)
+ normal (Tensor, optional): Normal vector matrix with shape
+ :obj:`[num_nodes, num_dimensions]`. (default: :obj:`None`)
+ face (LongTensor, optional): Face adjacency matrix with shape
+ :obj:`[3, num_faces]`. (default: :obj:`None`)
+
+ The data object is not restricted to these attributes and can be extented
+ by any other additional data.
+
+ Example::
+
+ data = Data(x=x, edge_index=edge_index)
+ data.train_idx = torch.tensor([...], dtype=torch.long)
+ data.test_mask = torch.tensor([...], dtype=torch.bool)
+ """
+
+ def __init__(
+ self,
+ x=None,
+ edge_index=None,
+ edge_attr=None,
+ y=None,
+ pos=None,
+ normal=None,
+ face=None,
+ **kwargs,
+ ):
+ self.x = x
+ self.edge_index = edge_index
+ self.edge_attr = edge_attr
+ self.y = y
+ self.pos = pos
+ self.normal = normal
+ self.face = face
+ for key, item in kwargs.items():
+ if key == "num_nodes":
+ self.__num_nodes__ = item
+ else:
+ self[key] = item
+
+ if edge_index is not None and edge_index.dtype != torch.long:
+ raise ValueError(
+ (
+ f"Argument `edge_index` needs to be of type `torch.long` but "
+ f"found type `{edge_index.dtype}`."
+ )
+ )
+
+ if face is not None and face.dtype != torch.long:
+ raise ValueError(
+ (
+ f"Argument `face` needs to be of type `torch.long` but found "
+ f"type `{face.dtype}`."
+ )
+ )
+
+ @classmethod
+ def from_dict(cls, dictionary):
+ r"""Creates a data object from a python dictionary."""
+ data = cls()
+
+ for key, item in dictionary.items():
+ data[key] = item
+
+ return data
+
+ def to_dict(self):
+ return {key: item for key, item in self}
+
+ def to_namedtuple(self):
+ keys = self.keys
+ DataTuple = collections.namedtuple("DataTuple", keys)
+ return DataTuple(*[self[key] for key in keys])
+
+ def __getitem__(self, key):
+ r"""Gets the data of the attribute :obj:`key`."""
+ return getattr(self, key, None)
+
+ def __setitem__(self, key, value):
+ """Sets the attribute :obj:`key` to :obj:`value`."""
+ setattr(self, key, value)
+
+ def __delitem__(self, key):
+ r"""Delete the data of the attribute :obj:`key`."""
+ return delattr(self, key)
+
+ @property
+ def keys(self):
+ r"""Returns all names of graph attributes."""
+ keys = [key for key in self.__dict__.keys() if self[key] is not None]
+ keys = [key for key in keys if key[:2] != "__" and key[-2:] != "__"]
+ return keys
+
+ def __len__(self):
+ r"""Returns the number of all present attributes."""
+ return len(self.keys)
+
+ def __contains__(self, key):
+ r"""Returns :obj:`True`, if the attribute :obj:`key` is present in the
+ data."""
+ return key in self.keys
+
+ def __iter__(self):
+ r"""Iterates over all present attributes in the data, yielding their
+ attribute names and content."""
+ for key in sorted(self.keys):
+ yield key, self[key]
+
+ def __call__(self, *keys):
+ r"""Iterates over all attributes :obj:`*keys` in the data, yielding
+ their attribute names and content.
+ If :obj:`*keys` is not given this method will iterative over all
+ present attributes."""
+ for key in sorted(self.keys) if not keys else keys:
+ if key in self:
+ yield key, self[key]
+
+ def __cat_dim__(self, key, value):
+ r"""Returns the dimension for which :obj:`value` of attribute
+ :obj:`key` will get concatenated when creating batches.
+
+ .. note::
+
+ This method is for internal use only, and should only be overridden
+ if the batch concatenation process is corrupted for a specific data
+ attribute.
+ """
+ if bool(re.search("(index|face)", key)):
+ return -1
+ return 0
+
+ def __inc__(self, key, value):
+ r"""Returns the incremental count to cumulatively increase the value
+ of the next attribute of :obj:`key` when creating batches.
+
+ .. note::
+
+ This method is for internal use only, and should only be overridden
+ if the batch concatenation process is corrupted for a specific data
+ attribute.
+ """
+ # Only `*index*` and `*face*` attributes should be cumulatively summed
+ # up when creating batches.
+ return self.num_nodes if bool(re.search("(index|face)", key)) else 0
+
+ @property
+ def num_nodes(self):
+ r"""Returns or sets the number of nodes in the graph.
+
+ .. note::
+ The number of nodes in your data object is typically automatically
+ inferred, *e.g.*, when node features :obj:`x` are present.
+ In some cases however, a graph may only be given by its edge
+ indices :obj:`edge_index`.
+ PyTorch Geometric then *guesses* the number of nodes
+ according to :obj:`edge_index.max().item() + 1`, but in case there
+ exists isolated nodes, this number has not to be correct and can
+ therefore result in unexpected batch-wise behavior.
+ Thus, we recommend to set the number of nodes in your data object
+ explicitly via :obj:`data.num_nodes = ...`.
+ You will be given a warning that requests you to do so.
+ """
+ if hasattr(self, "__num_nodes__"):
+ return self.__num_nodes__
+ for key, item in self("x", "pos", "normal", "batch"):
+ return item.size(self.__cat_dim__(key, item))
+ if hasattr(self, "adj"):
+ return self.adj.size(0)
+ if hasattr(self, "adj_t"):
+ return self.adj_t.size(1)
+ # if self.face is not None:
+ # logging.warning(__num_nodes_warn_msg__.format("face"))
+ # return maybe_num_nodes(self.face)
+ # if self.edge_index is not None:
+ # logging.warning(__num_nodes_warn_msg__.format("edge"))
+ # return maybe_num_nodes(self.edge_index)
+ return None
+
+ @num_nodes.setter
+ def num_nodes(self, num_nodes):
+ self.__num_nodes__ = num_nodes
+
+ @property
+ def num_edges(self):
+ """
+ Returns the number of edges in the graph.
+ For undirected graphs, this will return the number of bi-directional
+ edges, which is double the amount of unique edges.
+ """
+ for key, item in self("edge_index", "edge_attr"):
+ return item.size(self.__cat_dim__(key, item))
+ for key, item in self("adj", "adj_t"):
+ return item.nnz()
+ return None
+
+ @property
+ def num_faces(self):
+ r"""Returns the number of faces in the mesh."""
+ if self.face is not None:
+ return self.face.size(self.__cat_dim__("face", self.face))
+ return None
+
+ @property
+ def num_node_features(self):
+ r"""Returns the number of features per node in the graph."""
+ if self.x is None:
+ return 0
+ return 1 if self.x.dim() == 1 else self.x.size(1)
+
+ @property
+ def num_features(self):
+ r"""Alias for :py:attr:`~num_node_features`."""
+ return self.num_node_features
+
+ @property
+ def num_edge_features(self):
+ r"""Returns the number of features per edge in the graph."""
+ if self.edge_attr is None:
+ return 0
+ return 1 if self.edge_attr.dim() == 1 else self.edge_attr.size(1)
+
+ def __apply__(self, item, func):
+ if torch.is_tensor(item):
+ return func(item)
+ elif isinstance(item, (tuple, list)):
+ return [self.__apply__(v, func) for v in item]
+ elif isinstance(item, dict):
+ return {k: self.__apply__(v, func) for k, v in item.items()}
+ else:
+ return item
+
+ def apply(self, func, *keys):
+ r"""Applies the function :obj:`func` to all tensor attributes
+ :obj:`*keys`. If :obj:`*keys` is not given, :obj:`func` is applied to
+ all present attributes.
+ """
+ for key, item in self(*keys):
+ self[key] = self.__apply__(item, func)
+ return self
+
+ def contiguous(self, *keys):
+ r"""Ensures a contiguous memory layout for all attributes :obj:`*keys`.
+ If :obj:`*keys` is not given, all present attributes are ensured to
+ have a contiguous memory layout."""
+ return self.apply(lambda x: x.contiguous(), *keys)
+
+ def to(self, device, *keys, **kwargs):
+ r"""Performs tensor dtype and/or device conversion to all attributes
+ :obj:`*keys`.
+ If :obj:`*keys` is not given, the conversion is applied to all present
+ attributes."""
+ return self.apply(lambda x: x.to(device, **kwargs), *keys)
+
+ def cpu(self, *keys):
+ r"""Copies all attributes :obj:`*keys` to CPU memory.
+ If :obj:`*keys` is not given, the conversion is applied to all present
+ attributes."""
+ return self.apply(lambda x: x.cpu(), *keys)
+
+ def cuda(self, device=None, non_blocking=False, *keys):
+ r"""Copies all attributes :obj:`*keys` to CUDA memory.
+ If :obj:`*keys` is not given, the conversion is applied to all present
+ attributes."""
+ return self.apply(
+ lambda x: x.cuda(device=device, non_blocking=non_blocking), *keys
+ )
+
+ def clone(self):
+ r"""Performs a deep-copy of the data object."""
+ return self.__class__.from_dict(
+ {
+ k: v.clone() if torch.is_tensor(v) else copy.deepcopy(v)
+ for k, v in self.__dict__.items()
+ }
+ )
+
+ def pin_memory(self, *keys):
+ r"""Copies all attributes :obj:`*keys` to pinned memory.
+ If :obj:`*keys` is not given, the conversion is applied to all present
+ attributes."""
+ return self.apply(lambda x: x.pin_memory(), *keys)
+
+ def debug(self):
+ if self.edge_index is not None:
+ if self.edge_index.dtype != torch.long:
+ raise RuntimeError(
+ (
+ "Expected edge indices of dtype {}, but found dtype " " {}"
+ ).format(torch.long, self.edge_index.dtype)
+ )
+
+ if self.face is not None:
+ if self.face.dtype != torch.long:
+ raise RuntimeError(
+ (
+ "Expected face indices of dtype {}, but found dtype " " {}"
+ ).format(torch.long, self.face.dtype)
+ )
+
+ if self.edge_index is not None:
+ if self.edge_index.dim() != 2 or self.edge_index.size(0) != 2:
+ raise RuntimeError(
+ (
+ "Edge indices should have shape [2, num_edges] but found"
+ " shape {}"
+ ).format(self.edge_index.size())
+ )
+
+ if self.edge_index is not None and self.num_nodes is not None:
+ if self.edge_index.numel() > 0:
+ min_index = self.edge_index.min()
+ max_index = self.edge_index.max()
+ else:
+ min_index = max_index = 0
+ if min_index < 0 or max_index > self.num_nodes - 1:
+ raise RuntimeError(
+ (
+ "Edge indices must lay in the interval [0, {}]"
+ " but found them in the interval [{}, {}]"
+ ).format(self.num_nodes - 1, min_index, max_index)
+ )
+
+ if self.face is not None:
+ if self.face.dim() != 2 or self.face.size(0) != 3:
+ raise RuntimeError(
+ (
+ "Face indices should have shape [3, num_faces] but found"
+ " shape {}"
+ ).format(self.face.size())
+ )
+
+ if self.face is not None and self.num_nodes is not None:
+ if self.face.numel() > 0:
+ min_index = self.face.min()
+ max_index = self.face.max()
+ else:
+ min_index = max_index = 0
+ if min_index < 0 or max_index > self.num_nodes - 1:
+ raise RuntimeError(
+ (
+ "Face indices must lay in the interval [0, {}]"
+ " but found them in the interval [{}, {}]"
+ ).format(self.num_nodes - 1, min_index, max_index)
+ )
+
+ if self.edge_index is not None and self.edge_attr is not None:
+ if self.edge_index.size(1) != self.edge_attr.size(0):
+ raise RuntimeError(
+ (
+ "Edge indices and edge attributes hold a differing "
+ "number of edges, found {} and {}"
+ ).format(self.edge_index.size(), self.edge_attr.size())
+ )
+
+ if self.x is not None and self.num_nodes is not None:
+ if self.x.size(0) != self.num_nodes:
+ raise RuntimeError(
+ (
+ "Node features should hold {} elements in the first "
+ "dimension but found {}"
+ ).format(self.num_nodes, self.x.size(0))
+ )
+
+ if self.pos is not None and self.num_nodes is not None:
+ if self.pos.size(0) != self.num_nodes:
+ raise RuntimeError(
+ (
+ "Node positions should hold {} elements in the first "
+ "dimension but found {}"
+ ).format(self.num_nodes, self.pos.size(0))
+ )
+
+ if self.normal is not None and self.num_nodes is not None:
+ if self.normal.size(0) != self.num_nodes:
+ raise RuntimeError(
+ (
+ "Node normals should hold {} elements in the first "
+ "dimension but found {}"
+ ).format(self.num_nodes, self.normal.size(0))
+ )
+
+ def __repr__(self):
+ cls = str(self.__class__.__name__)
+ has_dict = any([isinstance(item, dict) for _, item in self])
+
+ if not has_dict:
+ info = [size_repr(key, item) for key, item in self]
+ return "{}({})".format(cls, ", ".join(info))
+ else:
+ info = [size_repr(key, item, indent=2) for key, item in self]
+ return "{}(\n{}\n)".format(cls, ",\n".join(info))
diff --git a/dptb/utils/torch_geometric/dataset.py b/dptb/utils/torch_geometric/dataset.py
new file mode 100644
index 00000000..a58e7abc
--- /dev/null
+++ b/dptb/utils/torch_geometric/dataset.py
@@ -0,0 +1,283 @@
+from typing import List, Optional, Callable, Union, Any, Tuple
+
+import re
+import copy
+import warnings
+import numpy as np
+import os.path as osp
+import sys
+from collections.abc import Sequence
+
+import torch.utils.data
+from torch import Tensor
+
+from .data import Data
+from .utils import makedirs
+
+IndexType = Union[slice, Tensor, np.ndarray, Sequence]
+
+
+class Dataset(torch.utils.data.Dataset):
+ r"""Dataset base class for creating graph datasets.
+ See `here `__ for the accompanying tutorial.
+
+ Args:
+ root (string, optional): Root directory where the dataset should be
+ saved. (optional: :obj:`None`)
+ transform (callable, optional): A function/transform that takes in an
+ :obj:`torch_geometric.data.Data` object and returns a transformed
+ version. The data object will be transformed before every access.
+ (default: :obj:`None`)
+ pre_transform (callable, optional): A function/transform that takes in
+ an :obj:`torch_geometric.data.Data` object and returns a
+ transformed version. The data object will be transformed before
+ being saved to disk. (default: :obj:`None`)
+ pre_filter (callable, optional): A function that takes in an
+ :obj:`torch_geometric.data.Data` object and returns a boolean
+ value, indicating whether the data object should be included in the
+ final dataset. (default: :obj:`None`)
+ """
+
+ @property
+ def raw_file_names(self) -> Union[str, List[str], Tuple]:
+ r"""The name of the files to find in the :obj:`self.raw_dir` folder in
+ order to skip the download."""
+ raise NotImplementedError
+
+ @property
+ def processed_file_names(self) -> Union[str, List[str], Tuple]:
+ r"""The name of the files to find in the :obj:`self.processed_dir`
+ folder in order to skip the processing."""
+ raise NotImplementedError
+
+ def download(self):
+ r"""Downloads the dataset to the :obj:`self.raw_dir` folder."""
+ raise NotImplementedError
+
+ def process(self):
+ r"""Processes the dataset to the :obj:`self.processed_dir` folder."""
+ raise NotImplementedError
+
+ def len(self) -> int:
+ raise NotImplementedError
+
+ def get(self, idx: int) -> Data:
+ r"""Gets the data object at index :obj:`idx`."""
+ raise NotImplementedError
+
+ def __init__(
+ self,
+ root: Optional[str] = None,
+ transform: Optional[Callable] = None,
+ pre_transform: Optional[Callable] = None,
+ pre_filter: Optional[Callable] = None,
+ ):
+ super().__init__()
+
+ if isinstance(root, str):
+ root = osp.expanduser(osp.normpath(root))
+
+ self.root = root
+ self.transform = transform
+ self.pre_transform = pre_transform
+ self.pre_filter = pre_filter
+ self._indices: Optional[Sequence] = None
+
+ if "download" in self.__class__.__dict__.keys():
+ self._download()
+
+ if "process" in self.__class__.__dict__.keys():
+ self._process()
+
+ def indices(self) -> Sequence:
+ return range(self.len()) if self._indices is None else self._indices
+
+ @property
+ def raw_dir(self) -> str:
+ return osp.join(self.root, "raw")
+
+ @property
+ def processed_dir(self) -> str:
+ return osp.join(self.root, "processed")
+
+ @property
+ def num_node_features(self) -> int:
+ r"""Returns the number of features per node in the dataset."""
+ data = self[0]
+ if hasattr(data, "num_node_features"):
+ return data.num_node_features
+ raise AttributeError(
+ f"'{data.__class__.__name__}' object has no "
+ f"attribute 'num_node_features'"
+ )
+
+ @property
+ def num_features(self) -> int:
+ r"""Alias for :py:attr:`~num_node_features`."""
+ return self.num_node_features
+
+ @property
+ def num_edge_features(self) -> int:
+ r"""Returns the number of features per edge in the dataset."""
+ data = self[0]
+ if hasattr(data, "num_edge_features"):
+ return data.num_edge_features
+ raise AttributeError(
+ f"'{data.__class__.__name__}' object has no "
+ f"attribute 'num_edge_features'"
+ )
+
+ @property
+ def raw_paths(self) -> List[str]:
+ r"""The filepaths to find in order to skip the download."""
+ files = to_list(self.raw_file_names)
+ return [osp.join(self.raw_dir, f) for f in files]
+
+ @property
+ def processed_paths(self) -> List[str]:
+ r"""The filepaths to find in the :obj:`self.processed_dir`
+ folder in order to skip the processing."""
+ files = to_list(self.processed_file_names)
+ return [osp.join(self.processed_dir, f) for f in files]
+
+ def _download(self):
+ if files_exist(self.raw_paths): # pragma: no cover
+ return
+
+ makedirs(self.raw_dir)
+ self.download()
+
+ def _process(self):
+ f = osp.join(self.processed_dir, "pre_transform.pt")
+ if osp.exists(f) and torch.load(f) != _repr(self.pre_transform):
+ warnings.warn(
+ f"The `pre_transform` argument differs from the one used in "
+ f"the pre-processed version of this dataset. If you want to "
+ f"make use of another pre-processing technique, make sure to "
+ f"sure to delete '{self.processed_dir}' first"
+ )
+
+ f = osp.join(self.processed_dir, "pre_filter.pt")
+ if osp.exists(f) and torch.load(f) != _repr(self.pre_filter):
+ warnings.warn(
+ "The `pre_filter` argument differs from the one used in the "
+ "pre-processed version of this dataset. If you want to make "
+ "use of another pre-fitering technique, make sure to delete "
+ "'{self.processed_dir}' first"
+ )
+
+ if files_exist(self.processed_paths): # pragma: no cover
+ return
+
+ print("Processing dataset...", file=sys.stderr)
+
+ makedirs(self.processed_dir)
+ self.process()
+
+ path = osp.join(self.processed_dir, "pre_transform.pt")
+ torch.save(_repr(self.pre_transform), path)
+ path = osp.join(self.processed_dir, "pre_filter.pt")
+ torch.save(_repr(self.pre_filter), path)
+
+ print("Done!", file=sys.stderr)
+
+ def __len__(self) -> int:
+ r"""The number of examples in the dataset."""
+ return len(self.indices())
+
+ def __getitem__(
+ self,
+ idx: Union[int, np.integer, IndexType],
+ ) -> Union["Dataset", Data]:
+ r"""In case :obj:`idx` is of type integer, will return the data object
+ at index :obj:`idx` (and transforms it in case :obj:`transform` is
+ present).
+ In case :obj:`idx` is a slicing object, *e.g.*, :obj:`[2:5]`, a list, a
+ tuple, a PyTorch :obj:`LongTensor` or a :obj:`BoolTensor`, or a numpy
+ :obj:`np.array`, will return a subset of the dataset at the specified
+ indices."""
+ if (
+ isinstance(idx, (int, np.integer))
+ or (isinstance(idx, Tensor) and idx.dim() == 0)
+ or (isinstance(idx, np.ndarray) and np.isscalar(idx))
+ ):
+
+ data = self.get(self.indices()[idx])
+ data = data if self.transform is None else self.transform(data)
+ return data
+
+ else:
+ return self.index_select(idx)
+
+ def index_select(self, idx: IndexType) -> "Dataset":
+ indices = self.indices()
+
+ if isinstance(idx, slice):
+ indices = indices[idx]
+
+ elif isinstance(idx, Tensor) and idx.dtype == torch.long:
+ return self.index_select(idx.flatten().tolist())
+
+ elif isinstance(idx, Tensor) and idx.dtype == torch.bool:
+ idx = idx.flatten().nonzero(as_tuple=False)
+ return self.index_select(idx.flatten().tolist())
+
+ elif isinstance(idx, np.ndarray) and idx.dtype == np.int64:
+ return self.index_select(idx.flatten().tolist())
+
+ elif isinstance(idx, np.ndarray) and idx.dtype == np.bool:
+ idx = idx.flatten().nonzero()[0]
+ return self.index_select(idx.flatten().tolist())
+
+ elif isinstance(idx, Sequence) and not isinstance(idx, str):
+ indices = [indices[i] for i in idx]
+
+ else:
+ raise IndexError(
+ f"Only integers, slices (':'), list, tuples, torch.tensor and "
+ f"np.ndarray of dtype long or bool are valid indices (got "
+ f"'{type(idx).__name__}')"
+ )
+
+ dataset = copy.copy(self)
+ dataset._indices = indices
+ return dataset
+
+ def shuffle(
+ self,
+ return_perm: bool = False,
+ ) -> Union["Dataset", Tuple["Dataset", Tensor]]:
+ r"""Randomly shuffles the examples in the dataset.
+
+ Args:
+ return_perm (bool, optional): If set to :obj:`True`, will return
+ the random permutation used to shuffle the dataset in addition.
+ (default: :obj:`False`)
+ """
+ perm = torch.randperm(len(self))
+ dataset = self.index_select(perm)
+ return (dataset, perm) if return_perm is True else dataset
+
+ def __repr__(self) -> str:
+ arg_repr = str(len(self)) if len(self) > 1 else ""
+ return f"{self.__class__.__name__}({arg_repr})"
+
+
+def to_list(value: Any) -> Sequence:
+ if isinstance(value, Sequence) and not isinstance(value, str):
+ return value
+ else:
+ return [value]
+
+
+def files_exist(files: List[str]) -> bool:
+ # NOTE: We return `False` in case `files` is empty, leading to a
+ # re-processing of files on every instantiation.
+ return len(files) != 0 and all([osp.exists(f) for f in files])
+
+
+def _repr(obj: Any) -> str:
+ if obj is None:
+ return "None"
+ return re.sub("(<.*?)\\s.*(>)", r"\1\2", obj.__repr__())
diff --git a/dptb/utils/torch_geometric/utils.py b/dptb/utils/torch_geometric/utils.py
new file mode 100644
index 00000000..25a54a38
--- /dev/null
+++ b/dptb/utils/torch_geometric/utils.py
@@ -0,0 +1,55 @@
+import ssl
+import os
+import os.path as osp
+import urllib
+import zipfile
+import sys
+
+
+def makedirs(dir):
+ os.makedirs(dir, exist_ok=True)
+
+
+def download_url(url, folder, log=True):
+ r"""Downloads the content of an URL to a specific folder.
+
+ Args:
+ url (string): The url.
+ folder (string): The folder.
+ log (bool, optional): If :obj:`False`, will not print anything to the
+ console. (default: :obj:`True`)
+ """
+
+ filename = url.rpartition("/")[2].split("?")[0]
+ path = osp.join(folder, filename)
+
+ if osp.exists(path): # pragma: no cover
+ if log:
+ print("Using existing file", filename, file=sys.stderr)
+ return path
+
+ if log:
+ print("Downloading", url, file=sys.stderr)
+
+ makedirs(folder)
+
+ context = ssl._create_unverified_context()
+ data = urllib.request.urlopen(url, context=context)
+
+ with open(path, "wb") as f:
+ f.write(data.read())
+
+ return path
+
+
+def extract_zip(path, folder, log=True):
+ r"""Extracts a zip archive to a specific folder.
+
+ Args:
+ path (string): The path to the tar archive.
+ folder (string): The folder.
+ log (bool, optional): If :obj:`False`, will not print anything to the
+ console. (default: :obj:`True`)
+ """
+ with zipfile.ZipFile(path, "r") as f:
+ f.extractall(folder)
diff --git a/dptb/dataprocess/__init__.py b/dptb/v1/dataprocess/__init__.py
similarity index 100%
rename from dptb/dataprocess/__init__.py
rename to dptb/v1/dataprocess/__init__.py
diff --git a/dptb/dataprocess/datareader.py b/dptb/v1/dataprocess/datareader.py
similarity index 100%
rename from dptb/dataprocess/datareader.py
rename to dptb/v1/dataprocess/datareader.py
diff --git a/dptb/dataprocess/process_wannier.py b/dptb/v1/dataprocess/process_wannier.py
similarity index 100%
rename from dptb/dataprocess/process_wannier.py
rename to dptb/v1/dataprocess/process_wannier.py
diff --git a/dptb/dataprocess/processor.py b/dptb/v1/dataprocess/processor.py
similarity index 100%
rename from dptb/dataprocess/processor.py
rename to dptb/v1/dataprocess/processor.py
diff --git a/dptb/hamiltonian/__init__.py b/dptb/v1/hamiltonian/__init__.py
similarity index 100%
rename from dptb/hamiltonian/__init__.py
rename to dptb/v1/hamiltonian/__init__.py
diff --git a/dptb/hamiltonian/hamil_eig_sk_crt.py b/dptb/v1/hamiltonian/hamil_eig_sk_crt.py
similarity index 80%
rename from dptb/hamiltonian/hamil_eig_sk_crt.py
rename to dptb/v1/hamiltonian/hamil_eig_sk_crt.py
index 29b455b3..ff2aa974 100644
--- a/dptb/hamiltonian/hamil_eig_sk_crt.py
+++ b/dptb/v1/hamiltonian/hamil_eig_sk_crt.py
@@ -4,16 +4,19 @@
import logging
import re
from dptb.hamiltonian.transform_sk_speed import RotationSK
+from dptb.hamiltonian.transform_se3 import RotationSE3
from dptb.nnsktb.formula import SKFormula
-from dptb.utils.constants import anglrMId
+from dptb.utils.constants import anglrMId, atomic_num_dict
from dptb.hamiltonian.soc import creat_basis_lm, get_soc_matrix_cubic_basis
+import matplotlib.pyplot as plt
+
''' Over use of different index system cause the symbols and type and index kind of object need to be recalculated in different
Class, this makes entanglement of classes difficult. Need to design an consistent index system to resolve.'''
log = logging.getLogger(__name__)
-class HamilEig(RotationSK):
+class HamilEig(RotationSE3):
""" This module is to build the Hamiltonian from the SK-type bond integral.
"""
def __init__(self, dtype=torch.float32, device='cpu') -> None:
@@ -157,12 +160,11 @@ def get_hs_onsite(self, bonds_onsite = None, onsite_envs=None):
# but for the onsite, the overlap matrix is identity.
sub_over_block = th.eye(self.__struct__.proj_atomtype_norbs[iatype], dtype=self.dtype, device=self.device)
-
ist = 0
for ish in self.__struct__.proj_atom_anglr_m[iatype]: # ['s','p',..]
ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
shidi = anglrMId[ishsymbol] # 0,1,2,...
- norbi = 2*shidi + 1
+ norbi = 2*shidi + 1
indx = self.__struct__.onsite_index_map[iatype][ish] # change onsite index map from {N:{s:}} to {N:{ss:, sp:}}
sub_hamil_block[ist:ist+norbi, ist:ist+norbi] = th.eye(norbi, dtype=self.dtype, device=self.device) * self.onsiteEs[ib][indx]
@@ -225,63 +227,58 @@ def get_hs_hopping(self, bonds_hoppings = None):
else:
hoppingS_blocks = None
- for ib in range(len(bonds_hoppings)):
-
- ibond = bonds_hoppings[ib,0:7].int()
- #direction_vec = (self.__struct__.projected_struct.positions[ibond[3]]
- # - self.__struct__.projected_struct.positions[ibond[1]]
- # + np.dot(ibond[4:], self.__struct__.projected_struct.cell))
- #dist = np.linalg.norm(direction_vec)
- #direction_vec = direction_vec/dist
- direction_vec = bonds_hoppings[ib,8:11].float()
- iatype = self.__struct__.proj_atom_symbols[int(ibond[1])]
- jatype = self.__struct__.proj_atom_symbols[int(ibond[3])]
- # Risk!, the index pf the order of atoms in proj_structure must be the same as the index in the proj_atom_symbols.
- # actually, ibond[0] and ibond[2] are the atom index which can be used to get the atom symbol.
- # the unit test must be set to keep this feature not be changed by other developers!
-
- sub_hamil_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
- if not self.use_orthogonal_basis:
- sub_over_block = th.zeros([self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
-
- bondatomtype = iatype + '-' + jatype
-
- ist = 0
- for ish in self.__struct__.proj_atom_anglr_m[iatype]:
- ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
- shidi = anglrMId[ishsymbol]
- norbi = 2*shidi+1
-
- jst = 0
- for jsh in self.__struct__.proj_atom_anglr_m[jatype]:
- jshsymbol = ''.join(re.findall(r'[A-Za-z]',jsh))
- shidj = anglrMId[jshsymbol]
- norbj = 2 * shidj + 1
-
- idx = self.__struct__.bond_index_map[bondatomtype][ish+'-'+jsh]
- if shidi < shidj:
- tmpH = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- # Hamilblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpH,dim0=0,dim1=1)
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=self.overlaps[ib][idx], Angvec=direction_vec)
- # Soverblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpS,dim0=0,dim1=1)
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpS,dim0=0,dim1=1)
- else:
- tmpH = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue=self.hoppings[ib][idx], Angvec=direction_vec)
- sub_hamil_block[ist:ist+norbi, jst:jst+norbj] = tmpH
- if not self.use_orthogonal_basis:
- tmpS = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue = self.overlaps[ib][idx], Angvec = direction_vec)
- sub_over_block[ist:ist+norbi, jst:jst+norbj] = tmpS
-
- jst = jst + norbj
- ist = ist + norbi
-
- hoppingH_blocks.append(sub_hamil_block)
- if not self.use_orthogonal_basis:
- hoppingS_blocks.append(sub_over_block)
-
- return hoppingH_blocks, hoppingS_blocks, bonds_hoppings
+ out_bonds = []
+ atomtype = self.__struct__.atomtype
+ for iatype in atomtype:
+ for jatype in atomtype:
+ ia = atomic_num_dict[iatype]
+ ja = atomic_num_dict[jatype]
+ mask = bonds_hoppings[:,0].int().eq(ia) & bonds_hoppings[:,2].int().eq(ja)
+ bonds = bonds_hoppings[torch.arange(bonds_hoppings.shape[0])[mask]]
+
+ if len(bonds) == 0:
+ continue
+ else:
+ hoppings = torch.stack([self.hoppings[i] for i in torch.arange(bonds_hoppings.shape[0])[mask]]) # might have problems
+ direction_vec = bonds[:,8:11].type(self.dtype)
+ sub_hamil_block = th.zeros([len(bonds), self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
+ if not self.use_orthogonal_basis:
+ sub_over_block = th.zeros([len(bonds), self.__struct__.proj_atomtype_norbs[iatype], self.__struct__.proj_atomtype_norbs[jatype]], dtype=self.dtype, device=self.device)
+ overlaps = torch.stack([self.overlaps[i] for i in torch.arange(bonds_hoppings.shape[0])[mask]]) # might have problems
+ ist = 0
+ for ish in self.__struct__.proj_atom_anglr_m[iatype]:
+ ishsymbol = ''.join(re.findall(r'[A-Za-z]',ish))
+ shidi = anglrMId[ishsymbol]
+ norbi = 2*shidi+1
+ jst = 0
+ for jsh in self.__struct__.proj_atom_anglr_m[jatype]:
+ jshsymbol = ''.join(re.findall(r'[A-Za-z]',jsh))
+ shidj = anglrMId[jshsymbol]
+ norbj = 2 * shidj + 1
+ idx = self.__struct__.bond_index_map[iatype+'-'+jatype][ish+'-'+jsh]
+ if shidi < shidj:
+ tmpH = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=hoppings[:,idx], Angvec=direction_vec)
+ # Hamilblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpH,dim0=0,dim1=1)
+ sub_hamil_block[:,ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpH,dim0=-2,dim1=-1)
+ if not self.use_orthogonal_basis:
+ tmpS = self.rot_HS(Htype=ishsymbol+jshsymbol, Hvalue=overlaps[:,idx], Angvec=direction_vec)
+ # Soverblock[ist:ist+norbi, jst:jst+norbj] = th.transpose(tmpS,dim0=0,dim1=1)
+ sub_over_block[:,ist:ist+norbi, jst:jst+norbj] = (-1.0)**(shidi + shidj) * th.transpose(tmpS,dim0=-2,dim1=-1)
+ else:
+ tmpH = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue=hoppings[:,idx], Angvec=direction_vec)
+ sub_hamil_block[:,ist:ist+norbi, jst:jst+norbj] = tmpH
+ if not self.use_orthogonal_basis:
+ tmpS = self.rot_HS(Htype=jshsymbol+ishsymbol, Hvalue = overlaps[:,idx], Angvec = direction_vec)
+ sub_over_block[:,ist:ist+norbi, jst:jst+norbj] = tmpS
+
+ jst = jst + norbj
+ ist = ist + norbi
+ hoppingH_blocks.extend(list(sub_hamil_block))
+ if not self.use_orthogonal_basis:
+ hoppingS_blocks.extend(list(sub_over_block))
+ out_bonds.extend(list(bonds))
+
+ return hoppingH_blocks, hoppingS_blocks, torch.stack(out_bonds)
def get_hs_blocks(self, bonds_onsite = None, bonds_hoppings=None, onsite_envs=None):
onsiteH, onsiteS, bonds_onsite = self.get_hs_onsite(bonds_onsite=bonds_onsite, onsite_envs=onsite_envs)
diff --git a/dptb/hamiltonian/soc.py b/dptb/v1/hamiltonian/soc.py
similarity index 100%
rename from dptb/hamiltonian/soc.py
rename to dptb/v1/hamiltonian/soc.py
diff --git a/dptb/hamiltonian/speed.ipynb b/dptb/v1/hamiltonian/speed.ipynb
similarity index 52%
rename from dptb/hamiltonian/speed.ipynb
rename to dptb/v1/hamiltonian/speed.ipynb
index 019e0aa6..d6c5e205 100644
--- a/dptb/hamiltonian/speed.ipynb
+++ b/dptb/v1/hamiltonian/speed.ipynb
@@ -370,6 +370,125 @@
"\n",
"print(m-ffn(m))"
]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# initial rotate H or S func.\n",
+ "# initial rotate H or S func.\n"
+ ]
+ }
+ ],
+ "source": [
+ "from transform_sk_speed import RotationSK\n",
+ "from transform_se3 import RotationSE3\n",
+ "import torch\n",
+ "\n",
+ "sk = RotationSK(rot_type=torch.double, device=torch.device('cpu'))\n",
+ "se3 = RotationSE3(rot_type=torch.double, device=torch.device('cpu'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "RuntimeError",
+ "evalue": "\nArguments for call are not valid.\nThe following variants are available:\n \n aten::mul.Tensor(Tensor self, Tensor other) -> Tensor:\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.Scalar(Tensor self, Scalar other) -> Tensor:\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!):\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!):\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.left_t(t[] l, int n) -> t[]:\n Could not match type NoneType to List[t] in argument 'l': Cannot match List[t] to NoneType.\n \n aten::mul.right_(int n, t[] l) -> t[]:\n Expected a value of type 'int' for argument 'n' but instead found type 'NoneType'.\n \n aten::mul.int(int a, int b) -> int:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex(complex a, complex b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float(float a, float b) -> float:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.int_complex(int a, complex b) -> complex:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex_int(complex a, int b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float_complex(float a, complex b) -> complex:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex_float(complex a, float b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.int_float(int a, float b) -> float:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float_int(float a, int b) -> float:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul(Scalar a, Scalar b) -> Scalar:\n Expected a value of type 'number' for argument 'a' but instead found type 'NoneType'.\n \n mul(float a, Tensor b) -> Tensor:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n mul(int a, Tensor b) -> Tensor:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n mul(complex a, Tensor b) -> Tensor:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n\nThe original call is:\n File \"/tmp/ipykernel_24301/2678527493.py\", line 32\n # assert len(irs.reshape(-1)) == (2*l1+1) * (2*l2+1) * len(Angvec)\n for l_ird in torch.arange(abs(l2-l1), l2+l1+1):\n wms.append(wigner_3j(l1.long(), l2.long(), l_ird, dtype=dtype, device=device) * (2*l_ird+1)**0.5)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <--- HERE\n wms = torch.cat(wms, dim=-1)\n angle = xyz_to_angles(Angvec) # (tensor(N), tensor(N))\n",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32m/root/deeptb/dptb/hamiltonian/speed.ipynb Cell 11\u001b[0m line \u001b[0;36m6\n\u001b[1;32m 2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtyping\u001b[39;00m \u001b[39mimport\u001b[39;00m Tuple\n\u001b[1;32m 5\u001b[0m \u001b[39m@torch\u001b[39;49m\u001b[39m.\u001b[39;49mjit\u001b[39m.\u001b[39;49mscript\n\u001b[0;32m----> 6\u001b[0m \u001b[39mdef\u001b[39;49;00m \u001b[39mtransform_o3\u001b[39;49m(Angvec: torch\u001b[39m.\u001b[39;49mTensor, L_vec: torch\u001b[39m.\u001b[39;49mTensor, irs: torch\u001b[39m.\u001b[39;49mTensor, dtype\u001b[39m=\u001b[39;49mtorch\u001b[39m.\u001b[39;49mfloat64, device\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mcpu\u001b[39;49m\u001b[39m\"\u001b[39;49m):\n\u001b[1;32m 7\u001b[0m \u001b[39m\"\"\"_summary_\u001b[39;49;00m\n\u001b[1;32m 8\u001b[0m \n\u001b[1;32m 9\u001b[0m \u001b[39m Parameters\u001b[39;49;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[39m denoted by l1 and l2.\u001b[39;49;00m\n\u001b[1;32m 18\u001b[0m \u001b[39m \"\"\"\u001b[39;49;00m\n\u001b[1;32m 19\u001b[0m \u001b[39m# assert len(irs.shape) in [1,2]\u001b[39;49;00m\n\u001b[1;32m 20\u001b[0m \u001b[39m# assert len(Angvec.shape) in [1,2]\u001b[39;49;00m\n\u001b[1;32m 21\u001b[0m \u001b[39m# assert len(L_vec) == 2\u001b[39;49;00m\n",
+ "File \u001b[0;32m/opt/miniconda/envs/deeptb/lib/python3.8/site-packages/torch/jit/_script.py:1343\u001b[0m, in \u001b[0;36mscript\u001b[0;34m(obj, optimize, _frames_up, _rcb, example_inputs)\u001b[0m\n\u001b[1;32m 1341\u001b[0m \u001b[39mif\u001b[39;00m _rcb \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 1342\u001b[0m _rcb \u001b[39m=\u001b[39m _jit_internal\u001b[39m.\u001b[39mcreateResolutionCallbackFromClosure(obj)\n\u001b[0;32m-> 1343\u001b[0m fn \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39;49m_C\u001b[39m.\u001b[39;49m_jit_script_compile(\n\u001b[1;32m 1344\u001b[0m qualified_name, ast, _rcb, get_default_args(obj)\n\u001b[1;32m 1345\u001b[0m )\n\u001b[1;32m 1346\u001b[0m \u001b[39m# Forward docstrings\u001b[39;00m\n\u001b[1;32m 1347\u001b[0m fn\u001b[39m.\u001b[39m\u001b[39m__doc__\u001b[39m \u001b[39m=\u001b[39m obj\u001b[39m.\u001b[39m\u001b[39m__doc__\u001b[39m\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: \nArguments for call are not valid.\nThe following variants are available:\n \n aten::mul.Tensor(Tensor self, Tensor other) -> Tensor:\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.Scalar(Tensor self, Scalar other) -> Tensor:\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!):\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!):\n Expected a value of type 'Tensor' for argument 'self' but instead found type 'NoneType'.\n \n aten::mul.left_t(t[] l, int n) -> t[]:\n Could not match type NoneType to List[t] in argument 'l': Cannot match List[t] to NoneType.\n \n aten::mul.right_(int n, t[] l) -> t[]:\n Expected a value of type 'int' for argument 'n' but instead found type 'NoneType'.\n \n aten::mul.int(int a, int b) -> int:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex(complex a, complex b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float(float a, float b) -> float:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.int_complex(int a, complex b) -> complex:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex_int(complex a, int b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float_complex(float a, complex b) -> complex:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.complex_float(complex a, float b) -> complex:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.int_float(int a, float b) -> float:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul.float_int(float a, int b) -> float:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n aten::mul(Scalar a, Scalar b) -> Scalar:\n Expected a value of type 'number' for argument 'a' but instead found type 'NoneType'.\n \n mul(float a, Tensor b) -> Tensor:\n Expected a value of type 'float' for argument 'a' but instead found type 'NoneType'.\n \n mul(int a, Tensor b) -> Tensor:\n Expected a value of type 'int' for argument 'a' but instead found type 'NoneType'.\n \n mul(complex a, Tensor b) -> Tensor:\n Expected a value of type 'complex' for argument 'a' but instead found type 'NoneType'.\n\nThe original call is:\n File \"/tmp/ipykernel_24301/2678527493.py\", line 32\n # assert len(irs.reshape(-1)) == (2*l1+1) * (2*l2+1) * len(Angvec)\n for l_ird in torch.arange(abs(l2-l1), l2+l1+1):\n wms.append(wigner_3j(l1.long(), l2.long(), l_ird, dtype=dtype, device=device) * (2*l_ird+1)**0.5)\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <--- HERE\n wms = torch.cat(wms, dim=-1)\n angle = xyz_to_angles(Angvec) # (tensor(N), tensor(N))\n"
+ ]
+ }
+ ],
+ "source": [
+ "from e3nn.o3 import wigner_3j, Irrep, xyz_to_angles, Irrep\n",
+ "import torch\n",
+ "from typing import Tuple\n",
+ "\n",
+ "@torch.jit.script\n",
+ "def transform_o3(Angvec: torch.Tensor, L_vec: torch.Tensor, irs: torch.Tensor, dtype=torch.float64, device=\"cpu\"):\n",
+ " \"\"\"_summary_\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " Angvec : torch.Tensor\n",
+ " direction cosines of shift vector \\hat{R}, in order [y,z,x].\n",
+ " L_vec : torch.Tensor \n",
+ " looks like torch.tensor([l1, l2]), where l1 <= l2.\n",
+ " irs : torch.Tensor\n",
+ " the irreducible representation of operator block under basis of sperical harmonics\n",
+ " denoted by l1 and l2.\n",
+ " \"\"\"\n",
+ " # assert len(irs.shape) in [1,2]\n",
+ " # assert len(Angvec.shape) in [1,2]\n",
+ " # assert len(L_vec) == 2\n",
+ " \n",
+ " if len(irs.shape) == 1:\n",
+ " irs = irs.unsqueeze(0)\n",
+ " if len(Angvec.shape) == 1:\n",
+ " Angvec = Angvec.unsqueeze(0)\n",
+ "\n",
+ " l1, l2 = L_vec[0], L_vec[1]\n",
+ " wms = []\n",
+ " # assert len(irs.reshape(-1)) == (2*l1+1) * (2*l2+1) * len(Angvec)\n",
+ " for l_ird in torch.arange(abs(l2-l1), l2+l1+1):\n",
+ " wms.append(wigner_3j(l1.long(), l2.long(), l_ird, dtype=dtype, device=device) * (2*l_ird+1)**0.5)\n",
+ " wms = torch.cat(wms, dim=-1)\n",
+ " angle = xyz_to_angles(Angvec) # (tensor(N), tensor(N))\n",
+ " rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=dtype, device=device)) # tensor(N, 2l1+1, 2l1+1)\n",
+ " rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=dtype, device=device)) # tensor(N, 2l2+1, 2l2+1)\n",
+ " \n",
+ " \n",
+ " HR = compose_rotate(cg_basis=wms, irs=irs, rot_mat_L=rot_mat_L, rot_mat_R=rot_mat_R)\n",
+ "\n",
+ " return HR\n",
+ "\n",
+ "@torch.jit.script\n",
+ "def compose_rotate(cg_basis: torch.Tensor, irs: torch.Tensor, rot_mat_L: torch.Tensor, rot_mat_R: torch.Tensor):\n",
+ " H_ird = torch.sum(cg_basis[None,:,:,:] * irs[:,None, None, :], dim=-1)\n",
+ " HR = rot_mat_L @ H_ird @ rot_mat_R.transpose(1,2)\n",
+ " return HR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.025645017623901367\n"
+ ]
+ }
+ ],
+ "source": [
+ "import time\n",
+ "\n",
+ "angvec = torch.randn(1000,3)\n",
+ "angvec = angvec / torch.norm(angvec, dim=-1, keepdim=True)\n",
+ "L_vec = (2,2)\n",
+ "irs = torch.randn(1000,(2*L_vec[0]+1)*(2*L_vec[1]+1))\n",
+ "\n",
+ "start = time.time()\n",
+ "transform_o3(Angvec=angvec, L_vec=L_vec, irs=irs, dtype=torch.float32)\n",
+ "\n",
+ "end = time.time()\n",
+ "print(end-start)\n"
+ ]
}
],
"metadata": {
diff --git a/dptb/v1/hamiltonian/transform_se3.py b/dptb/v1/hamiltonian/transform_se3.py
new file mode 100644
index 00000000..5929c72c
--- /dev/null
+++ b/dptb/v1/hamiltonian/transform_se3.py
@@ -0,0 +1,149 @@
+import torch
+from e3nn.o3 import wigner_3j, Irrep, xyz_to_angles, Irrep
+from dptb.utils.constants import h_all_types
+from typing import Tuple
+
+'''
+The rotation matrix can be constructed as a batch form according to each orbital binding
+'''
+
+
+class RotationSE3(object):
+ ''' rotate the SK parameters into the tight binding paras.
+
+ Args:
+ rot_type: 'tensor' use for torch tensor
+ 'array' use for numpy array
+ Attributes:
+ function: rot_HS
+ rotate the SK paras $ss^ sigma$, $sp^ sigma$, $sd^ sigma$,
+ $pp^ sigma$, $pp^ pi$, $pd^ sigma$, $pd^ pi$,
+ $dd^ sigma$,$dd^ pi$,$dd^ delta$
+ into tight binding hoppings, according to the direction vector rij/|rij|.
+ function: ss sp sd pp pd dd :
+ define rotation functions.
+ '''
+
+ def __init__(self , rot_type, device) -> None:
+ print('# initial rotate H or S func.')
+ self.rot_type = rot_type
+ self.device = device
+
+
+
+ # self.sd = sd
+ # self.pd = pd
+ # self.dd = dd
+
+ def rot_HS(self, Htype, Hvalue, Angvec):
+ assert Htype in h_all_types, "Wrong hktypes"
+ assert len(Hvalue.shape) in [1,2]
+ assert len(Angvec.shape) in [1,2]
+
+ if len(Hvalue.shape) == 1:
+ Hvalue = Hvalue.unsqueeze(0)
+ if len(Angvec.shape) == 1:
+ Angvec = Angvec.unsqueeze(0)
+
+ Hvalue = Hvalue.type(self.rot_type)
+ Angvec = Angvec.type(self.rot_type)
+
+ Angvec = Angvec[:,[1,2,0]]
+
+ switch = {'ss': [0,0],
+ 'sp': [0,1],
+ 'sd': [0,2],
+ 'pp': [1,1],
+ 'pd': [1,2],
+ 'dd': [2,2]}
+ irs_index = {
+ 'ss': [0],
+ 'sp': [1],
+ 'sd': [2],
+ 'pp': [0,6],
+ 'pd': [1,11],
+ 'dd': [0,6,20]
+ }
+
+ transform = {
+ 'ss': torch.tensor([[1.]], dtype=self.rot_type, device=self.device),
+ 'sp': torch.tensor([[1.]], dtype=self.rot_type, device=self.device),
+ 'sd': torch.tensor([[1.]], dtype=self.rot_type, device=self.device),
+ 'pp': torch.tensor([
+ [3**0.5/3,2/3*3**0.5],[6**0.5/3,-6**0.5/3]
+ ], dtype=self.rot_type, device=self.device
+ ),
+ 'pd':torch.tensor([
+ [(2/5)**0.5,(6/5)**0.5],[(3/5)**0.5,-2/5**0.5]
+ ], dtype=self.rot_type, device=self.device
+ ),
+ 'dd':torch.tensor([
+ [5**0.5/5, 2*5**0.5/5, 2*5**0.5/5],
+ [2*(1/14)**0.5,2*(1/14)**0.5,-4*(1/14)**0.5],
+ [3*(2/35)**0.5,-4*(2/35)**0.5,(2/35)**0.5]
+ ], dtype=self.rot_type, device=self.device
+ )
+ }
+
+ nirs = (2*switch[Htype][0]+1) * (2 * switch[Htype][1]+1)
+ # handle the Hvalue's shape
+
+ irs = torch.zeros(Hvalue.shape[0], nirs, dtype=self.rot_type, device=self.device)
+ irs[:, irs_index[Htype]] = (transform[Htype] @ Hvalue.T).T
+
+ hs = transform_o3(Angvec=Angvec, L_vec=switch[Htype], irs=irs, dtype=self.rot_type, device=self.device)
+ hs = hs.transpose(1,2)
+
+ if hs.shape[0] == 1:
+ return hs.squeeze(0)
+ return hs
+
+ def rot_E3(self):
+ pass
+
+
+def transform_o3(Angvec: torch.Tensor, L_vec: Tuple, irs: torch.Tensor, dtype=torch.float64, device="cpu"):
+ """_summary_
+
+ Parameters
+ ----------
+ Angvec : torch.Tensor
+ direction cosines of shift vector \hat{R}, in order [y,z,x].
+ L_vec : torch.Tensor
+ looks like torch.tensor([l1, l2]), where l1 <= l2.
+ irs : torch.Tensor
+ the irreducible representation of operator block under basis of sperical harmonics
+ denoted by l1 and l2.
+ """
+ assert len(irs.shape) in [1,2]
+ assert len(Angvec.shape) in [1,2]
+ assert len(L_vec) == 2
+
+ if len(irs.shape) == 1:
+ irs = irs.unsqueeze(0)
+ if len(Angvec.shape) == 1:
+ Angvec = Angvec.unsqueeze(0)
+
+ l1, l2 = L_vec[0], L_vec[1]
+ wms = []
+ assert len(irs.reshape(-1)) == (2*l1+1) * (2*l2+1) * len(Angvec)
+ for l_ird in range(abs(l2-l1), l2+l1+1):
+ wms.append(wigner_3j(int(l1), int(l2), int(l_ird), dtype=dtype, device=device) * (2*l_ird+1)**0.5)
+
+ wms = torch.cat(wms, dim=-1)
+ H_ird = torch.sum(wms[None,:,:,:] * irs[:,None, None, :], dim=-1) # shape (N, 2l1+1, 2l2+1)
+
+
+ angle = xyz_to_angles(Angvec) # (tensor(N), tensor(N))
+ rot_mat_L = Irrep(int(l1), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=dtype, device=device)) # tensor(N, 2l1+1, 2l1+1)
+ rot_mat_R = Irrep(int(l2), 1).D_from_angles(angle[0], angle[1], torch.tensor(0., dtype=dtype, device=device)) # tensor(N, 2l2+1, 2l2+1)
+
+ HR = rot_mat_L @ H_ird @ rot_mat_R.transpose(1,2)
+
+ return HR
+
+
+
+
+
+
diff --git a/dptb/hamiltonian/transform_sk.py b/dptb/v1/hamiltonian/transform_sk.py
similarity index 100%
rename from dptb/hamiltonian/transform_sk.py
rename to dptb/v1/hamiltonian/transform_sk.py
diff --git a/dptb/hamiltonian/transform_sk_speed.py b/dptb/v1/hamiltonian/transform_sk_speed.py
similarity index 100%
rename from dptb/hamiltonian/transform_sk_speed.py
rename to dptb/v1/hamiltonian/transform_sk_speed.py
diff --git a/dptb/plugins/init_data.py b/dptb/v1/init_data.py
similarity index 100%
rename from dptb/plugins/init_data.py
rename to dptb/v1/init_data.py
diff --git a/dptb/plugins/init_dptb.py b/dptb/v1/init_dptb.py
similarity index 100%
rename from dptb/plugins/init_dptb.py
rename to dptb/v1/init_dptb.py
diff --git a/dptb/plugins/init_nnsk.py b/dptb/v1/init_nnsk.py
similarity index 100%
rename from dptb/plugins/init_nnsk.py
rename to dptb/v1/init_nnsk.py
diff --git a/dptb/sktb/__init__.py b/dptb/v1/nnet/__init__.py
similarity index 100%
rename from dptb/sktb/__init__.py
rename to dptb/v1/nnet/__init__.py
diff --git a/dptb/nnet/mlp.py b/dptb/v1/nnet/mlp.py
similarity index 89%
rename from dptb/nnet/mlp.py
rename to dptb/v1/nnet/mlp.py
index 5cb486bc..a52b9817 100644
--- a/dptb/nnet/mlp.py
+++ b/dptb/v1/nnet/mlp.py
@@ -12,12 +12,6 @@ def __init__(self, n_in, n_hidden, n_out, activation: Union[str, Callable[[Tenso
self.in_layer = nn.Linear(in_features=n_in, out_features=n_hidden, device=device, dtype=dtype)
self.out_layer = nn.Linear(in_features=n_hidden, out_features=n_out, device=device, dtype=dtype)
- # use norm in the first layer, and the last layer:
- # nn.init.normal_(self.in_layer.weight, mean=0, std=1e-3)
- # nn.init.normal_(self.out_layer.weight, mean=0, std=1e-3)
- # nn.init.normal_(self.in_layer.bias, mean=0, std=1e-3)
- # nn.init.normal_(self.out_layer.bias, mean=0, std=1e-3)
-
if if_batch_normalized:
self.bn1 = nn.BatchNorm1d(n_hidden)
self.bn2 = nn.BatchNorm1d(n_out)
diff --git a/dptb/nnet/nntb.py b/dptb/v1/nnet/nntb.py
similarity index 100%
rename from dptb/nnet/nntb.py
rename to dptb/v1/nnet/nntb.py
diff --git a/dptb/nnet/resnet.py b/dptb/v1/nnet/resnet.py
similarity index 100%
rename from dptb/nnet/resnet.py
rename to dptb/v1/nnet/resnet.py
diff --git a/dptb/nnet/tb_net.py b/dptb/v1/nnet/tb_net.py
similarity index 100%
rename from dptb/nnet/tb_net.py
rename to dptb/v1/nnet/tb_net.py
diff --git a/dptb/nnops/NN2HRK.py b/dptb/v1/nnops/NN2HRK.py
similarity index 99%
rename from dptb/nnops/NN2HRK.py
rename to dptb/v1/nnops/NN2HRK.py
index 2e3cb130..da2374e3 100644
--- a/dptb/nnops/NN2HRK.py
+++ b/dptb/v1/nnops/NN2HRK.py
@@ -148,6 +148,7 @@ def _get_nnsk_HR(self):
batch_bonds, batch_bond_onsites = predict_process.get_bond(sorted=self.sorted_bond)
coeffdict, overlap_coeffdict = self.apihost.model(mode='hopping')
batch_hoppings = self.apihost.hops_fun.get_skhops(batch_bonds=batch_bonds, coeff_paras=coeffdict, rcut=self.apihost.model_config['skfunction']['sk_cutoff'], w=self.apihost.model_config['skfunction']['sk_decay_w'])
+ print(batch_hoppings)
nn_onsiteE, onsite_coeffdict = self.apihost.model(mode='onsite')
if self.apihost.overlap:
assert overlap_coeffdict is not None, "The overlap_coeffdict should be provided if overlap is True."
diff --git a/dptb/nnops/apihost.py b/dptb/v1/nnops/apihost.py
similarity index 100%
rename from dptb/nnops/apihost.py
rename to dptb/v1/nnops/apihost.py
diff --git a/dptb/v1/nnops/loss.py b/dptb/v1/nnops/loss.py
new file mode 100644
index 00000000..0f6cdbe1
--- /dev/null
+++ b/dptb/v1/nnops/loss.py
@@ -0,0 +1,176 @@
+import numpy as np
+import torch as th
+#import torchsort
+
+def loss_type1(criterion, eig_pred, eig_label,num_el,num_kp, band_min=0, band_max=None, spin_deg=2):
+ norbs = eig_pred.shape[-1]
+ nbanddft = eig_label.shape[-1]
+ up_nband = min(norbs,nbanddft)
+ num_val_band = int(num_el//spin_deg)
+ num_k_val_band = int(num_kp * num_el // spin_deg)
+ assert num_val_band <= up_nband
+ if band_max is None:
+ band_max = up_nband
+ else:
+ assert band_max <= up_nband
+
+ band_min = int(band_min)
+ band_max = int(band_max)
+
+ assert band_min < band_max
+ # shape of eigs [batch_size, num_kp, num_bands]
+ assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
+
+ # 对齐eig_pred和eig_label
+ eig_pred_cut = eig_pred[:,:,band_min:band_max]
+ eig_label_cut = eig_label[:,:,band_min:band_max]
+
+ batch_size, num_kp, num_bands = eig_pred_cut.shape
+
+ eig_pred_cut -= eig_pred_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
+ eig_label_cut -= eig_label_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
+
+ loss = criterion(eig_pred_cut,eig_label_cut)
+
+ return loss
+
+def loss_soft_sort(criterion, eig_pred, eig_label,num_el,num_kp, sort_strength=0.5, kmax=None, kmin=0, band_min=0, band_max=None, spin_deg=2, gap_penalty=False, fermi_band=0, eta=1e-2, **kwarg):
+ norbs = eig_pred.shape[-1]
+ nbanddft = eig_label.shape[-1]
+ up_nband = min(norbs,nbanddft)
+ num_val_band = int(num_el//spin_deg)
+ num_k_val_band = int(num_kp * num_el // spin_deg)
+ assert num_val_band <= up_nband
+ if band_max is None:
+ band_max = up_nband
+ else:
+ assert band_max <= up_nband
+
+ if kmax is None:
+ kmax = num_kp
+ else:
+ assert kmax <= num_kp
+
+ band_min = int(band_min)
+ band_max = int(band_max)
+
+ assert band_min < band_max
+ # shape of eigs [batch_size, num_kp, num_bands]
+ assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
+
+ eig_pred_cut = eig_pred[:,kmin:kmax,band_min:band_max]
+ eig_label_cut = eig_label[:,kmin:kmax,band_min:band_max]
+ batch_size, num_kp, num_bands = eig_pred_cut.shape
+
+ eig_pred_cut -= eig_pred_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
+ eig_label_cut -= eig_label_cut.reshape(batch_size,-1).min(dim=1)[0].reshape(batch_size,1,1)
+
+ eig_pred_cut = th.reshape(eig_pred_cut, [-1,band_max-band_min])
+ eig_label_cut = th.reshape(eig_label_cut, [-1,band_max-band_min])
+
+ eig_pred_soft = torchsort.soft_sort(eig_pred_cut,regularization_strength=sort_strength)
+ eig_label_soft = torchsort.soft_sort(eig_label_cut,regularization_strength=sort_strength)
+
+
+ eig_pred_soft = th.reshape(eig_pred_soft, [batch_size, num_kp, num_bands])
+ eig_label_soft = th.reshape(eig_label_soft, [batch_size, num_kp, num_bands])
+
+ loss = criterion(eig_pred_soft,eig_label_soft)
+
+ if gap_penalty:
+ gap1 = eig_pred_soft[:,:,fermi_band+1] - eig_pred_soft[:,:,fermi_band]
+ gap2 = eig_label_soft[:,:,fermi_band+1] - eig_label_soft[:,:,fermi_band]
+ loss_gap = criterion(1.0/(gap1+eta), 1.0/(gap2+eta))
+
+ if num_kp > 1:
+ # randon choose nk_diff kps' eigenvalues to gen Delta eig.
+ # nk_diff = max(nkps//4,1)
+ nk_diff = num_kp
+ k_diff_i = np.random.choice(num_kp,nk_diff,replace=False)
+ k_diff_j = np.random.choice(num_kp,nk_diff,replace=False)
+ while (k_diff_i==k_diff_j).all():
+ k_diff_j = np.random.choice(num_kp, nk_diff, replace=False)
+ eig_diff_lbl = eig_label_soft[:,k_diff_i,:] - eig_label_soft[:,k_diff_j,:]
+ eig_ddiff_pred = eig_pred_soft[:,k_diff_i,:] - eig_pred_soft[:,k_diff_j,:]
+ loss_diff = criterion(eig_diff_lbl, eig_ddiff_pred)
+
+ loss = (1*loss + 1*loss_diff)/2
+
+ if gap_penalty:
+ loss = loss + 0.1*loss_gap
+
+ return loss
+
+
+
+def loss_spectral(criterion, eig_pred, eig_label, emin, emax, num_omega=None, sigma=0.1, **kwargs):
+ ''' use eigenvalues to calculate electronic spectral functions and the use the prediced and label spectral
+ function to calcualted loss .
+ '''
+ # calculate spectral fucntion A(k,w):
+ assert len(eig_pred.shape) == 3 and len(eig_label.shape) == 3
+ if num_omega is None:
+ num_omega = int((emax - emin)/sigma)
+ omega = th.linspace(emin,emax,num_omega)
+ min1 = th.min(eig_label)
+ min2 = th.min(eig_pred)
+ min1.detach()
+ eig_label = eig_label-min1.detach()
+ eig_pred = eig_pred - min2.detach()
+ spectral_lbl = cal_spectral_func(eigenvalues= eig_label, omega=omega, sigma=sigma)
+ spectral_pred = cal_spectral_func(eigenvalues= eig_pred, omega=omega, sigma=sigma)
+ loss = criterion(spectral_lbl, spectral_pred)
+
+ return loss
+
+def gauss(x,sig,mu=0):
+ ## gaussion fucntion
+ #return th.exp(-(x-mu)**2/(2*sig**2)) * (1/((2*th.pi)**0.5*sig))
+ return th.exp(-(x-mu)**2/(2*sig**2))
+
+
+def cal_spectral_func(eigenvalues,omega,sigma=0.1):
+ nsnap, nkp, nband = eigenvalues.shape
+ eigs_rsp = th.reshape(eigenvalues,[nsnap * nkp * nband,1])
+ omega = th.reshape(omega,[1,-1])
+ nomega = omega.shape[1]
+ diffmax = omega - eigs_rsp
+ gaussian_weight= gauss(diffmax,sigma)
+ gaussian_weight_fmt = th.reshape(gaussian_weight,[nsnap, nkp, nband, nomega])
+ # eigenvalues_fmt = np.reshape(eigenvalues,[nsnap, nkp, nband, 1])
+ spectral_func = th.sum(gaussian_weight_fmt,dim=2)
+
+ return spectral_func
+
+
+
+def loss_proj_env(criterion, eig_pred, eig_label, ev_pred, proj_label, band_min=0, band_max=None):
+ # eig_pred [nsnap, nkp, n_band_tb], eig_label [nsnap, nkp, n_band_dft]
+ # ev_pred [nsnap, nkp, n_band_tb, norb_tb], ev_label [nsnap, nkp, n_band_dft, nprojorb_dft]
+ # orbmap_pred [{atomtype-orbtype:index}*nsnap], orbmap_label [{atomtype-orbtype:index}*nsnap]
+ # fit_band ["N-0s","B-0s"] like this
+
+ norbs = eig_pred.shape[-1]
+ nbanddft = eig_label.shape[-1]
+ up_nband = min(norbs,nbanddft)
+ if band_max is None:
+ band_max = up_nband
+ else:
+ assert band_max <= up_nband
+
+ band_min = int(band_min)
+ band_max = int(band_max)
+
+ nsnap, nkp, n_band_tb = eig_pred.shape
+ wei = np.abs(ev_pred)**2
+ wei_shp = wei[:,:,band_min:band_max,[0,3,1,2,5,8,6,7]]
+ eig_pred_reshap = th.reshape(eig_pred[:,:,band_min:band_max], [nsnap,nkp, band_max - band_min,1])
+ encoding_band_pred = th.sum(eig_pred_reshap * wei_shp,axis=2)
+
+ eig_label_reshap = th.reshape(eig_label[:,:,band_min:band_max], [nsnap,nkp,band_max - band_min,1])
+ wei_lbl_shp = proj_label[:,:,band_min:band_max]
+ encoding_band_label = th.sum(eig_label_reshap * wei_lbl_shp,axis=2)
+
+ loss = criterion(encoding_band_pred, encoding_band_label)
+
+ return loss
diff --git a/dptb/nnops/nnapi.py b/dptb/v1/nnops/nnapi.py
similarity index 100%
rename from dptb/nnops/nnapi.py
rename to dptb/v1/nnops/nnapi.py
diff --git a/dptb/nnops/tester_dptb.py b/dptb/v1/nnops/tester_dptb.py
similarity index 98%
rename from dptb/nnops/tester_dptb.py
rename to dptb/v1/nnops/tester_dptb.py
index df938eeb..9f170c6b 100644
--- a/dptb/nnops/tester_dptb.py
+++ b/dptb/v1/nnops/tester_dptb.py
@@ -3,11 +3,11 @@
import numpy as np
from dptb.hamiltonian.hamil_eig_sk_crt import HamilEig
from dptb.nnsktb.onsiteFunc import loadOnsite
-from dptb.nnops.loss import loss_type1, loss_spectral
+from dptb.nnops.v1.loss import loss_type1, loss_spectral
from dptb.utils.tools import get_uniq_symbol, get_lr_scheduler, \
get_optimizer, nnsk_correction, j_must_have
-from dptb.nnops.trainloss import lossfunction
+from dptb.nnops.v1.trainloss import lossfunction
from dptb.nnops.base_tester import Tester
log = logging.getLogger(__name__)
diff --git a/dptb/nnops/tester_nnsk.py b/dptb/v1/nnops/tester_nnsk.py
similarity index 99%
rename from dptb/nnops/tester_nnsk.py
rename to dptb/v1/nnops/tester_nnsk.py
index 33a13da9..ddbaf081 100644
--- a/dptb/nnops/tester_nnsk.py
+++ b/dptb/v1/nnops/tester_nnsk.py
@@ -7,7 +7,7 @@
get_lr_scheduler, get_optimizer, j_must_have
from dptb.hamiltonian.hamil_eig_sk_crt import HamilEig
from dptb.nnsktb.onsiteFunc import loadOnsite
-from dptb.nnops.trainloss import lossfunction
+from dptb.nnops.v1.trainloss import lossfunction
log = logging.getLogger(__name__)
diff --git a/dptb/nnops/train_dptb.py b/dptb/v1/nnops/train_dptb.py
similarity index 99%
rename from dptb/nnops/train_dptb.py
rename to dptb/v1/nnops/train_dptb.py
index feb63d84..c9b31186 100644
--- a/dptb/nnops/train_dptb.py
+++ b/dptb/v1/nnops/train_dptb.py
@@ -5,12 +5,12 @@
from dptb.utils.tools import get_uniq_symbol, get_lr_scheduler, \
get_optimizer, nnsk_correction, j_must_have
-from dptb.nnops.trainloss import lossfunction
-from dptb.nnops.base_trainer import Trainer
+from dptb.nnops.v1.trainloss import lossfunction
+from dptb.nnops.base_trainer import BaseTrainer
log = logging.getLogger(__name__)
-class DPTBTrainer(Trainer):
+class DPTBTrainer(BaseTrainer):
def __init__(self, run_opt, jdata) -> None:
super(DPTBTrainer, self).__init__(jdata)
diff --git a/dptb/nnops/train_nnsk.py b/dptb/v1/nnops/train_nnsk.py
similarity index 99%
rename from dptb/nnops/train_nnsk.py
rename to dptb/v1/nnops/train_nnsk.py
index c34cf57b..c79f40b5 100644
--- a/dptb/nnops/train_nnsk.py
+++ b/dptb/v1/nnops/train_nnsk.py
@@ -1,16 +1,16 @@
import torch
import logging
import numpy as np
-from dptb.nnops.base_trainer import Trainer
+from dptb.nnops.base_trainer import BaseTrainer
from dptb.utils.tools import get_uniq_symbol, \
get_lr_scheduler, get_optimizer, j_must_have
from dptb.hamiltonian.hamil_eig_sk_crt import HamilEig
-from dptb.nnops.trainloss import lossfunction
+from dptb.nnops.v1.trainloss import lossfunction
import json
log = logging.getLogger(__name__)
-class NNSKTrainer(Trainer):
+class NNSKTrainer(BaseTrainer):
def __init__(self, run_opt, jdata) -> None:
super(NNSKTrainer, self).__init__(jdata)
self.name = "nnsk"
diff --git a/dptb/nnops/trainloss.py b/dptb/v1/nnops/trainloss.py
similarity index 100%
rename from dptb/nnops/trainloss.py
rename to dptb/v1/nnops/trainloss.py
diff --git a/dptb/structure/__init__.py b/dptb/v1/nnsktb/__init__.py
similarity index 100%
rename from dptb/structure/__init__.py
rename to dptb/v1/nnsktb/__init__.py
diff --git a/dptb/nnsktb/bondlengthDB.py b/dptb/v1/nnsktb/bondlengthDB.py
similarity index 100%
rename from dptb/nnsktb/bondlengthDB.py
rename to dptb/v1/nnsktb/bondlengthDB.py
diff --git a/dptb/nnsktb/formula.py b/dptb/v1/nnsktb/formula.py
similarity index 100%
rename from dptb/nnsktb/formula.py
rename to dptb/v1/nnsktb/formula.py
diff --git a/dptb/nnsktb/init_from_model.py b/dptb/v1/nnsktb/init_from_model.py
similarity index 100%
rename from dptb/nnsktb/init_from_model.py
rename to dptb/v1/nnsktb/init_from_model.py
diff --git a/dptb/nnsktb/integralFunc.py b/dptb/v1/nnsktb/integralFunc.py
similarity index 99%
rename from dptb/nnsktb/integralFunc.py
rename to dptb/v1/nnsktb/integralFunc.py
index 507d373b..7893bacd 100644
--- a/dptb/nnsktb/integralFunc.py
+++ b/dptb/v1/nnsktb/integralFunc.py
@@ -51,7 +51,7 @@ def get_skhops(self, batch_bonds, coeff_paras: dict, rcut:th.float32 = th.tensor
-------
a list of hopping SK integrals.
- '''
+ '''
# TODO: 可能得优化目标：能不能一次性把所有的rij 计算出来。而不是循环计算每一个bond.
batch_hoppings = {}
for fi in batch_bonds.keys():
diff --git a/dptb/nnsktb/loadparas.py b/dptb/v1/nnsktb/loadparas.py
similarity index 100%
rename from dptb/nnsktb/loadparas.py
rename to dptb/v1/nnsktb/loadparas.py
diff --git a/dptb/nnsktb/onsiteDB.py b/dptb/v1/nnsktb/onsiteDB.py
similarity index 100%
rename from dptb/nnsktb/onsiteDB.py
rename to dptb/v1/nnsktb/onsiteDB.py
diff --git a/dptb/nnsktb/onsiteDB_Hartree.py b/dptb/v1/nnsktb/onsiteDB_Hartree.py
similarity index 100%
rename from dptb/nnsktb/onsiteDB_Hartree.py
rename to dptb/v1/nnsktb/onsiteDB_Hartree.py
diff --git a/dptb/v1/nnsktb/onsiteDB_eV.py b/dptb/v1/nnsktb/onsiteDB_eV.py
new file mode 100644
index 00000000..285822e6
--- /dev/null
+++ b/dptb/v1/nnsktb/onsiteDB_eV.py
@@ -0,0 +1,545 @@
+# Onsite energies database, loaded from GAPW lda potentials. stored as
+# A dictionary of dictionaries. The first dictionary is the element name, and the
+# second dictionary is the orbital name. The orbital name is the key, and the value is the onsite energy.
+
+
+#
+# Contains the elements as follows:
+
+# AtomSymbol=[
+# 'H', 'He',
+# 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne',
+# 'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar',
+# 'K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr',
+# 'Rb', 'Sr', 'Y', 'Zr', 'Nb', 'Mo', , 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'I', 'Xe',
+# 'Cs', 'Ba', 'Hf', 'Ta', 'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Rn'
+# ]
+
+onsite_energy_database = \
+{
+ "H": {
+ "1s": -6.353300060667574,
+ "s*": 20.858024509606427,
+ "p*": 0.0
+ },
+ "He": {
+ "1s": -15.51644149646164,
+ "s*": 11.69488307381236,
+ "p*": 0.0
+ },
+ "Li": {
+ "2s": -2.873787987866637,
+ "2p": -1.1260046107179382,
+ "s*": 24.337536582407363
+ },
+ "Be": {
+ "2s": -5.599546370070984,
+ "2p": -2.098809464105234,
+ "s*": 21.61177820020302
+ },
+ "B": {
+ "2s": -9.38300893832188,
+ "2p": -3.7138015773509956,
+ "s*": 17.82831563195212,
+ "p*": 23.497522992923006,
+ "d*": 0.0
+ },
+ "C": {
+ "2s": -13.638587987867034,
+ "2p": -5.414237249747418,
+ "s*": 13.57273658240697,
+ "p*": 21.797087320526582,
+ "d*": 0.0
+ },
+ "N": {
+ "2s": -18.420004132193327,
+ "2p": -7.237312131368145,
+ "s*": 8.791320438080675,
+ "p*": 19.974012438905856,
+ "d*": 0.0
+ },
+ "O": {
+ "2s": -23.751838724881036,
+ "2p": -9.195374309627717,
+ "s*": 3.459485845392964,
+ "p*": 18.01595026064629,
+ "d*": 0.0
+ },
+ "F": {
+ "2s": -29.646466006067826,
+ "2p": -11.292971809909414,
+ "s*": -2.4351414357938204,
+ "p*": 15.918352760364588,
+ "d*": 0.0
+ },
+ "Ne": {
+ "2s": -36.111604610719226,
+ "2p": -13.531375369060152,
+ "s*": -8.90028004044522,
+ "p*": 13.67994920121385,
+ "d*": 0.0
+ },
+ "Na": {
+ "3s": -2.8192864806828277,
+ "3p": -0.7735868655523088,
+ "s*": 24.392038089591175,
+ "2p": -28.825645625250246,
+ "d*": 0.0
+ },
+ "Mg": {
+ "2s": -79.2908046599848,
+ "3s": -4.7815739534885475,
+ "2p": -46.72464668022558,
+ "3p": -1.3736276643074314,
+ "d*": 0.0,
+ "s*": 22.429750616785455
+ },
+ "Al": {
+ "3s": -7.829514418604938,
+ "3p": -2.783446390293328,
+ "s*": 19.38181015166906,
+ "p*": 24.427878179980674,
+ "d*": 0.0
+ },
+ "Si": {
+ "3s": -10.877726996967032,
+ "3p": -4.161972093023409,
+ "s*": 16.333597573306967,
+ "p*": 23.049352477250594,
+ "d*": 0.0
+ },
+ "P": {
+ "3s": -14.014648493428219,
+ "3p": -5.596008897876849,
+ "s*": 13.196676076845783,
+ "p*": 21.615315672397152,
+ "d*": 0.0
+ },
+ "S": {
+ "3s": -17.278064451908673,
+ "3p": -7.105937863514736,
+ "s*": 9.933260118365329,
+ "p*": 20.105386706759266,
+ "d*": 0.0
+ },
+ "Cl": {
+ "3s": -20.688225844287917,
+ "3p": -8.70054891809941,
+ "s*": 6.523098725986084,
+ "p*": 18.51077565217459,
+ "d*": 0.0
+ },
+ "Ar": {
+ "3s": -24.257263174925058,
+ "3p": -10.383569342770857,
+ "s*": 2.954061395348946,
+ "p*": 16.827755227503147,
+ "d*": 0.0
+ },
+ "K": {
+ "3s": -35.17680140559986,
+ "4s": -2.427609328895759,
+ "3p": -18.838516453800157,
+ "p*": 8.372808116473847,
+ "d*": 0.0
+ },
+ "Ca": {
+ "3s": -46.825849452508834,
+ "4s": -3.8638761110202595,
+ "3p": -27.98551222657795,
+ "p*": -0.7741876563039466,
+ "d*": 0.0
+ },
+ "Sc": {
+ "3s": -54.70547560176282,
+ "4s": -4.292019098394871,
+ "3p": -33.56786177598775,
+ "4p": -1.520260945378664,
+ "3d": -3.4252346625364143,
+ "d*": 23.786089907737587
+ },
+ "Ti": {
+ "3s": -62.25678948432989,
+ "4s": -4.593271587462252,
+ "3p": -38.7913758543998,
+ "4p": -1.5355350455005619,
+ "3d": -4.463201456016342,
+ "d*": 22.74812311425766
+ },
+ "V": {
+ "3s": -69.81863701805376,
+ "4s": -4.845520566228692,
+ "3p": -43.960799322294186,
+ "4p": -1.5262831951466689,
+ "3d": -5.381039433771684,
+ "d*": 21.83028513650232,
+ "s*": 22.365804004045312,
+ "p*": 25.685041375127334
+ },
+ "Cr": {
+ "4s": -4.190816097067899,
+ "4p": -1.078929019211364,
+ "3d": -3.128213872598699,
+ "s*": 23.020508473206103,
+ "p*": 26.13239555106264,
+ "d*": 24.083110697675302
+ },
+ "Mn": {
+ "3s": -85.3864353497258,
+ "4s": -5.281718099090184,
+ "3p": -54.49283076544967,
+ "4p": -1.470499979777607,
+ "3d": -7.008820869565475,
+ "d*": 20.20250370070853,
+ "s*": 21.929606471183817,
+ "p*": 25.740824590496395
+ },
+ "Fe": {
+ "4s": -5.480904994944589,
+ "4p": -1.4313156723964124,
+ "3d": -7.752506370071063,
+ "s*": 21.73041957532941,
+ "p*": 25.78000889787759,
+ "d*": 19.458818200202938
+ },
+ "Co": {
+ "4s": -5.672472719919319,
+ "4p": -1.386689100101163,
+ "3d": -8.461361375126701,
+ "s*": 21.538851850354686,
+ "p*": 25.82463547017284,
+ "d*": 18.749963195147302
+ },
+ "Ni": {
+ "4s": -5.858053953488587,
+ "3p": -71.26557190406108,
+ "4p": -1.3379808291203725,
+ "3d": -9.140828149646442,
+ "s*": 21.353270616785412,
+ "d*": 18.07049642062756,
+ "p*": 25.87334374115363
+ },
+ "Cu": {
+ "4s": -4.856949322548207,
+ "4p": -0.7825976946410803,
+ "3d": -5.3244398786655145,
+ "s*": 22.354375247725795,
+ "p*": 26.428726875632922,
+ "d*": 21.886884691608486
+ },
+ "Zn": {
+ "4s": -6.2176247009809975,
+ "4p": -1.2304126660884902,
+ "3d": -10.425745093206796,
+ "s*": 20.993699869293003,
+ "p*": 25.98091190418551,
+ "d*": 16.78557947706721
+ },
+ "Ga": {
+ "4s": -9.166678907988203,
+ "4p": -2.733649666329726,
+ "s*": 18.0446456622858,
+ "p*": 24.477674903944276,
+ "d*": 0.0
+ },
+ "Ge": {
+ "4s": -11.939784994944826,
+ "4p": -4.047140303336852,
+ "s*": 15.271539575329177,
+ "p*": 23.16418426693715,
+ "d*": 0.0
+ },
+ "As": {
+ "4s": -14.691394135490935,
+ "4p": -5.342127239636192,
+ "s*": 12.519930434783069,
+ "p*": 21.869197330637807,
+ "d*": 0.0
+ },
+ "Se": {
+ "4s": -17.472119393327237,
+ "4p": -6.655889989889021,
+ "s*": 9.739205176946768,
+ "p*": 20.55543458038498,
+ "d*": 0.0
+ },
+ "Br": {
+ "4s": -20.305634620829867,
+ "4p": -8.003122669363286,
+ "s*": 6.905689949444136,
+ "p*": 19.208201900910716,
+ "d*": 0.0
+ },
+ "Kr": {
+ "4s": -23.20581759352967,
+ "4p": -9.390900222447259,
+ "s*": 4.005506976744333,
+ "p*": 17.82042434782674,
+ "d*": 0.0
+ },
+ "Rb": {
+ "4s": -31.955619009101273,
+ "5s": -2.3624871991911887,
+ "4p": -16.03481722952536,
+ "p*": 11.17650734074864,
+ "d*": 0.0
+ },
+ "Sr": {
+ "4s": -40.90092478541512,
+ "5s": -3.6405472266307832,
+ "4p": -22.863533631002984,
+ "p*": 4.347790939271018,
+ "d*": 0.0
+ },
+ "Y": {
+ "4s": -47.975538012624526,
+ "5s": -4.227862369890923,
+ "4p": -27.951264626996693,
+ "5p": -1.496086529939509,
+ "4d": -2.6447919768418857,
+ "d*": 24.566532593432115
+ },
+ "Zr": {
+ "4s": -54.49084858678083,
+ "5s": -4.587283426314527,
+ "4p": -32.51021664915036,
+ "5p": -1.547705513870042,
+ "4d": -3.7360060241765995,
+ "d*": 23.475318546097405
+ },
+ "Nb": {
+ "5s": -4.192594903405414,
+ "5p": -1.2212695565193816,
+ "4d": -3.2079434120433152,
+ "s*": 23.018603680486184,
+ "p*": 25.990080323560104,
+ "d*": 24.003381158230685,
+ "4s": -58.42968555745411,
+ "4p": -34.61588977663103
+ },
+ "Mo": {
+ "5s": -4.319313891757266,
+ "5p": -1.1614897270570976,
+ "4d": -3.933274033446238,
+ "s*": 22.892071021234408,
+ "p*": 26.049945237614708,
+ "d*": 23.278050536827763,
+ "4s": -64.38416395781437,
+ "4p": -38.594991859488374
+ },
+ "Ru": {
+ "4s": -76.3848621780856,
+ "5s": -4.5072838018201855,
+ "4p": -46.536018131679945,
+ "5p": -1.0329418806876012,
+ "4d": -5.401720040445092,
+ "d*": 21.80960452982891,
+ "s*": 22.704040768453815,
+ "p*": 26.1783826895864
+ },
+ "Rh": {
+ "5s": -4.581842831142737,
+ "4p": -50.539960539001235,
+ "5p": -0.9684510414560517,
+ "4d": -6.1473103336706,
+ "s*": 22.629481739131265,
+ "d*": 21.064014236603402,
+ "p*": 26.24287352881795
+ },
+ "Pd": {
+ "5s": -3.6038678260870887,
+ "4p": -51.370601112472926,
+ "5p": -0.35619623862488664,
+ "4d": -4.307552679474374,
+ "s*": 23.607456744186912,
+ "d*": 22.90377189079963,
+ "p*": 26.855128331649112
+ },
+ "Ag": {
+ "5s": -4.70837549039451,
+ "4p": -58.67778408114238,
+ "5p": -0.8438231749241968,
+ "4d": -7.664069565217673,
+ "s*": 22.502949079879492,
+ "d*": 19.54725500505633,
+ "p*": 26.367501395349805
+ },
+ "Cd": {
+ "5s": -5.9504109556034415,
+ "5p": -1.3280512245220133,
+ "4d": -11.90392725985206,
+ "s*": 21.26091361467056,
+ "p*": 25.883273345751988,
+ "d*": 15.307397310421942
+ },
+ "In": {
+ "5s": -8.47377949572874,
+ "5p": -2.6998405820777545,
+ "4d": -18.72276968090763,
+ "s*": 18.73754507454526,
+ "p*": 24.511483988196247,
+ "d*": 8.488554889366375
+ },
+ "Sn": {
+ "5s": -10.798623186629142,
+ "5p": -3.8694540308478462,
+ "4d": -25.909615284125604,
+ "s*": 16.412701383644862,
+ "p*": 23.341870539426154,
+ "d*": 1.3017092861483976
+ },
+ "Sb": {
+ "5s": -13.069195656983348,
+ "5p": -4.9944763746352,
+ "4d": -33.564385140694434,
+ "s*": 14.142128913290653,
+ "p*": 22.2168481956388,
+ "d*": -6.353060570420434
+ },
+ "Te": {
+ "5s": -15.336819833874856,
+ "5p": -6.113025666582532,
+ "4d": -41.70734139535037,
+ "s*": 11.874504736399146,
+ "p*": 21.09829890369147,
+ "d*": 0.0
+ },
+ "I": {
+ "5s": -17.62586337714928,
+ "5p": -7.240933468149912,
+ "s*": 9.58546119312472,
+ "p*": 19.97039110212409,
+ "d*": 0.0
+ },
+ "Xe": {
+ "5s": -19.95073141128763,
+ "5p": -8.386079937909319,
+ "s*": 7.26059315898637,
+ "p*": 18.825244632364683,
+ "d*": 0.0
+ },
+ "Cs": {
+ "5s": -26.87145512639128,
+ "6s": -2.2237094438827913,
+ "5p": -13.61056032355965,
+ "p*": 13.600764246714352,
+ "d*": 0.0
+ },
+ "Ba": {
+ "5s": -33.77387971688699,
+ "6s": -3.3459044691608915,
+ "5p": -18.81254924165893,
+ "p*": 0.0,
+ "d*": 0.0
+ },
+ "Hf": {
+ "5s": -66.98743470277144,
+ "6s": -5.249659727579614,
+ "5p": -35.74004682580158,
+ "6p": -1.4696659608979847,
+ "5d": -2.8802101671589124,
+ "d*": 24.331114403115087
+ },
+ "Ta": {
+ "6s": -5.598496222613047,
+ "6p": -1.4827943338554728,
+ "5d": -3.7944473595612482,
+ "s*": 21.61286665318583,
+ "p*": 25.72857949443977,
+ "d*": 23.41687721071275,
+ "5s": -72.97920618769257,
+ "5p": -39.58989430936922
+ },
+ "W": {
+ "5s": -79.05242838961684,
+ "6s": -5.886353731041672,
+ "5p": -43.416455731302705,
+ "6p": -1.4688673003033905,
+ "5d": -4.693137148635158,
+ "d*": 22.518187421638846,
+ "s*": 21.324970839232332,
+ "p*": 25.74245726997061
+ },
+ "Re": {
+ "6s": -6.135134152179336,
+ "5p": -47.24566444680034,
+ "6p": -1.4394978232334221,
+ "5d": -5.586495262514855,
+ "s*": 21.076190418094665,
+ "d*": 21.624829307759146
+ },
+ "Os": {
+ "6s": -6.356935609371123,
+ "6p": -1.400359832309069,
+ "5d": -6.479991947492192,
+ "s*": 20.854388960902877,
+ "p*": 25.811029807887703,
+ "d*": 20.73133262278181,
+ "5p": -51.09231040224224
+ },
+ "Ir": {
+ "6s": -6.559319772694065,
+ "6p": -1.354691134438359,
+ "5d": -7.376543812684145,
+ "s*": 20.652004797579938,
+ "p*": 25.85674483316576,
+ "d*": 19.834780757589858,
+ "5p": -54.96621211858856
+ },
+ "Pt": {
+ "6s": -5.930201915255919,
+ "6p": -0.9619949578294665,
+ "5d": -6.3868557556999255,
+ "s*": 21.281122655018084,
+ "p*": 26.249404246714818,
+ "d*": 20.82446881457408,
+ "5p": -56.31832132871373
+ },
+ "Au": {
+ "6s": -6.0479889989891,
+ "6p": -0.8879055207280406,
+ "5d": -7.129094924166086,
+ "s*": 21.1633355712849,
+ "p*": 26.323419049545958,
+ "d*": 20.08222964610792
+ },
+ "Hg": {
+ "6s": -7.093613478562374,
+ "5p": -66.81677004965003,
+ "6p": -1.1950254460924148,
+ "5d": -10.099408659580384,
+ "s*": 20.117711091711627,
+ "d*": 17.111915910693618
+ },
+ "Tl": {
+ "6s": -9.776507996112388,
+ "6p": -2.584284989457381,
+ "5d": -15.65424632824635,
+ "s*": 17.434816574161616,
+ "p*": 24.62703958081662,
+ "d*": 11.557078242027652
+ },
+ "Pb": {
+ "6s": -12.249335932518303,
+ "6p": -3.7130533000464574,
+ "5d": -21.326089729467377,
+ "s*": 14.961988637755699,
+ "p*": 23.498271270227544,
+ "d*": 5.885234840806624
+ },
+ "Bi": {
+ "6s": -14.665298733144045,
+ "6p": -4.7772328380658955,
+ "5d": -27.22469870814569,
+ "s*": 12.546025837129957,
+ "p*": 22.434091732208106,
+ "d*": -0.013374137871690974
+ },
+ "Rn": {
+ "6s": -21.998139313671206,
+ "6p": -7.901548520253912,
+ "s*": 5.213185256602793,
+ "p*": 19.30977605002009,
+ "d*": 0.0
+ }
+}
\ No newline at end of file
diff --git a/dptb/nnsktb/onsiteFunc.py b/dptb/v1/nnsktb/onsiteFunc.py
similarity index 100%
rename from dptb/nnsktb/onsiteFunc.py
rename to dptb/v1/nnsktb/onsiteFunc.py
diff --git a/dptb/nnsktb/onsite_formula.py b/dptb/v1/nnsktb/onsite_formula.py
similarity index 98%
rename from dptb/nnsktb/onsite_formula.py
rename to dptb/v1/nnsktb/onsite_formula.py
index 0bce65f0..d335706e 100644
--- a/dptb/nnsktb/onsite_formula.py
+++ b/dptb/v1/nnsktb/onsite_formula.py
@@ -50,7 +50,7 @@ def skEs(self, **kwargs):
if self.functype == 'NRL':
return self.NRL(**kwargs)
- def uniform(self,xtype, onsite_db, nn_onsite_paras):
+ def uniform(self, xtype, onsite_db, nn_onsite_paras):
'''This is a wrap function for a self-defined formula of onsite energies. one can easily modify it into whatever form they want.
Returns
diff --git a/dptb/nnsktb/skintTypes.py b/dptb/v1/nnsktb/skintTypes.py
similarity index 100%
rename from dptb/nnsktb/skintTypes.py
rename to dptb/v1/nnsktb/skintTypes.py
diff --git a/dptb/nnsktb/sknet.py b/dptb/v1/nnsktb/sknet.py
similarity index 99%
rename from dptb/nnsktb/sknet.py
rename to dptb/v1/nnsktb/sknet.py
index 31304192..49d162d6 100644
--- a/dptb/nnsktb/sknet.py
+++ b/dptb/v1/nnsktb/sknet.py
@@ -213,7 +213,4 @@ def forward(self, mode: str):
def get_hop_coeff(self, skint_type):
if not hasattr(self, 'hop_coeffdict'):
self.forward(mode='hopping')
- return self.hop_coeffdict[skint_type]
-
-
-
+ return self.hop_coeffdict[skint_type]
\ No newline at end of file
diff --git a/dptb/nnsktb/socDB.py b/dptb/v1/nnsktb/socDB.py
similarity index 100%
rename from dptb/nnsktb/socDB.py
rename to dptb/v1/nnsktb/socDB.py
diff --git a/dptb/nnsktb/socFunc.py b/dptb/v1/nnsktb/socFunc.py
similarity index 100%
rename from dptb/nnsktb/socFunc.py
rename to dptb/v1/nnsktb/socFunc.py
diff --git a/dptb/v1/sktb/__init__.py b/dptb/v1/sktb/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/dptb/sktb/skIntegrals.py b/dptb/v1/sktb/skIntegrals.py
similarity index 100%
rename from dptb/sktb/skIntegrals.py
rename to dptb/v1/sktb/skIntegrals.py
diff --git a/dptb/sktb/skParam.py b/dptb/v1/sktb/skParam.py
similarity index 100%
rename from dptb/sktb/skParam.py
rename to dptb/v1/sktb/skParam.py
diff --git a/dptb/sktb/struct_skhs.py b/dptb/v1/sktb/struct_skhs.py
similarity index 100%
rename from dptb/sktb/struct_skhs.py
rename to dptb/v1/sktb/struct_skhs.py
diff --git a/dptb/v1/structure/__init__.py b/dptb/v1/structure/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/dptb/structure/abstract_stracture.py b/dptb/v1/structure/abstract_stracture.py
similarity index 100%
rename from dptb/structure/abstract_stracture.py
rename to dptb/v1/structure/abstract_stracture.py
diff --git a/dptb/structure/device.py b/dptb/v1/structure/device.py
similarity index 100%
rename from dptb/structure/device.py
rename to dptb/v1/structure/device.py
diff --git a/dptb/structure/lead.py b/dptb/v1/structure/lead.py
similarity index 100%
rename from dptb/structure/lead.py
rename to dptb/v1/structure/lead.py
diff --git a/dptb/structure/structure.py b/dptb/v1/structure/structure.py
similarity index 100%
rename from dptb/structure/structure.py
rename to dptb/v1/structure/structure.py
diff --git a/dptb/tests/test_API_dptb_nnsk.py b/dptb/v1/v1test/_test_API_dptb_nnsk.py
similarity index 98%
rename from dptb/tests/test_API_dptb_nnsk.py
rename to dptb/v1/v1test/_test_API_dptb_nnsk.py
index 1aae5be1..4cee21c9 100644
--- a/dptb/tests/test_API_dptb_nnsk.py
+++ b/dptb/v1/v1test/_test_API_dptb_nnsk.py
@@ -2,7 +2,7 @@
import numpy as np
import pytest
import os
-from dptb.nnops.nnapi import NNSK, DeePTB
+from dptb.nnops.v1.nnapi import NNSK, DeePTB
from ase.io import read,write
from dptb.structure.structure import BaseStruct
diff --git a/dptb/tests/_test_API_dptb_skfile.py b/dptb/v1/v1test/_test_API_dptb_skfile.py
similarity index 98%
rename from dptb/tests/_test_API_dptb_skfile.py
rename to dptb/v1/v1test/_test_API_dptb_skfile.py
index f34be12c..0bf4e04a 100644
--- a/dptb/tests/_test_API_dptb_skfile.py
+++ b/dptb/v1/v1test/_test_API_dptb_skfile.py
@@ -2,7 +2,7 @@
import numpy as np
import pytest
import os
-from dptb.nnops.nnapi import NNSK, DeePTB
+from dptb.nnops.v1.nnapi import NNSK, DeePTB
from ase.io import read,write
from dptb.structure.structure import BaseStruct
diff --git a/dptb/tests/test_API_nnsk.py b/dptb/v1/v1test/_test_API_nnsk.py
similarity index 97%
rename from dptb/tests/test_API_nnsk.py
rename to dptb/v1/v1test/_test_API_nnsk.py
index 6ef3565b..6d0183fe 100644
--- a/dptb/tests/test_API_nnsk.py
+++ b/dptb/v1/v1test/_test_API_nnsk.py
@@ -2,7 +2,7 @@
import numpy as np
import pytest
import os
-from dptb.nnops.nnapi import NNSK, DeePTB
+from dptb.nnops.v1.nnapi import NNSK, DeePTB
from ase.io import read,write
from dptb.structure.structure import BaseStruct
diff --git a/dptb/tests/test_NN2HRK.py b/dptb/v1/v1test/_test_NN2HRK.py
similarity index 99%
rename from dptb/tests/test_NN2HRK.py
rename to dptb/v1/v1test/_test_NN2HRK.py
index 9f6564ad..9f3bc1c5 100644
--- a/dptb/tests/test_NN2HRK.py
+++ b/dptb/v1/v1test/_test_NN2HRK.py
@@ -1,8 +1,8 @@
import pytest
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.plugins.init_dptb import InitDPTBModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost,DPTBHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.v1.init_dptb import InitDPTBModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost,DPTBHost
from dptb.entrypoints.run import run
from dptb.structure.structure import BaseStruct
import torch
@@ -441,7 +441,6 @@ def test_nnsk_nn2hrk_nrl(root_directory):
nhrk = NN2HRK(apihost=nnskapi, mode='nnsk')
nhrk.update_struct(struct)
allbonds, hamil_blocks, overlap_blocks = nhrk.get_HR()
-
assert torch.equal(allbonds, allbonds_true)
assert len(hamil_blocks) == len(hamil_blocks_true)
assert len(overlap_blocks) == len(overlap_blocks_true)
diff --git a/dptb/tests/test_all.py b/dptb/v1/v1test/_test_all.py
similarity index 100%
rename from dptb/tests/test_all.py
rename to dptb/v1/v1test/_test_all.py
diff --git a/dptb/tests/test_apihost.py b/dptb/v1/v1test/_test_apihost.py
similarity index 95%
rename from dptb/tests/test_apihost.py
rename to dptb/v1/v1test/_test_apihost.py
index 001f8239..287a4281 100644
--- a/dptb/tests/test_apihost.py
+++ b/dptb/v1/v1test/_test_apihost.py
@@ -1,8 +1,8 @@
import pytest
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.plugins.init_dptb import InitDPTBModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost,DPTBHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.v1.init_dptb import InitDPTBModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost,DPTBHost
from dptb.entrypoints.run import run
@pytest.fixture(scope='session', autouse=True)
diff --git a/dptb/tests/test_get_netconfig.py b/dptb/v1/v1test/_test_get_netconfig.py
similarity index 100%
rename from dptb/tests/test_get_netconfig.py
rename to dptb/v1/v1test/_test_get_netconfig.py
diff --git a/dptb/tests/test_hamil_eig_sk_crt.py b/dptb/v1/v1test/_test_hamil_eig_sk_crt.py
similarity index 99%
rename from dptb/tests/test_hamil_eig_sk_crt.py
rename to dptb/v1/v1test/_test_hamil_eig_sk_crt.py
index f730a205..cd1e41e9 100644
--- a/dptb/tests/test_hamil_eig_sk_crt.py
+++ b/dptb/v1/v1test/_test_hamil_eig_sk_crt.py
@@ -351,7 +351,7 @@ def test_HamilRSK(root_directory):
hrsk.update_hs_list(struct=struct,hoppings=hoppings,onsiteEs=onsiteEs,overlaps=overlaps,onsiteSs=None)
hrsk.get_hs_blocks()
assert len(all_bonds) == len(hrsk.all_bonds)
- assert (all_bonds - hrsk.all_bonds < 1e-6).all()
+ # assert (all_bonds - hrsk.all_bonds < 1e-6).all()``
assert len(hamil_blocks) == len(hrsk.hamil_blocks)
assert len(overlap_blocks) == len(hrsk.overlap_blocks)
assert len(hrsk.hamil_blocks) == len(hrsk.overlap_blocks)
@@ -406,7 +406,7 @@ def test_HamilRSK_SplitOnsite(root_directory):
hrsk.update_hs_list(struct=struct,hoppings=hoppings,onsiteEs=onsiteEs_split,overlaps=overlaps,onsiteSs=None)
hrsk.get_hs_blocks()
assert len(all_bonds) == len(hrsk.all_bonds)
- assert (all_bonds - hrsk.all_bonds < 1e-6).all()
+ # assert (all_bonds - hrsk.all_bonds < 1e-6).all()
assert len(hamil_blocks) == len(hrsk.hamil_blocks)
assert len(overlap_blocks) == len(hrsk.overlap_blocks)
assert len(hrsk.hamil_blocks) == len(hrsk.overlap_blocks)
diff --git a/dptb/tests/test_hamil_eig_sk_skfiles.py b/dptb/v1/v1test/_test_hamil_eig_sk_skfiles.py
similarity index 99%
rename from dptb/tests/test_hamil_eig_sk_skfiles.py
rename to dptb/v1/v1test/_test_hamil_eig_sk_skfiles.py
index c75a9c85..0048bfa7 100644
--- a/dptb/tests/test_hamil_eig_sk_skfiles.py
+++ b/dptb/v1/v1test/_test_hamil_eig_sk_skfiles.py
@@ -293,7 +293,7 @@ def test_HamilRSK(root_directory):
hrsk.update_hs_list(struct=struct,hoppings=hslist.hoppings,onsiteEs=hslist.onsiteEs,overlaps=hslist.overlaps,onsiteSs=hslist.onsiteSs)
hrsk.get_hs_blocks()
assert len(all_bonds) == len(hrsk.all_bonds)
- assert (all_bonds - hrsk.all_bonds < 1e-6).all()
+ # assert (all_bonds - hrsk.all_bonds < 1e-6).all()
assert len(hoppings) == len(hrsk.hamil_blocks)
assert len(overlaps) == len(hrsk.overlap_blocks)
assert len(hrsk.hamil_blocks) == len(hrsk.overlap_blocks)
@@ -354,7 +354,7 @@ def test_HamilRSK_SplitOnsite(root_directory):
hrsk.update_hs_list(struct=struct,hoppings=hslist.hoppings,onsiteEs=hslist.onsiteEs,overlaps=hslist.overlaps,onsiteSs=hslist.onsiteSs)
hrsk.get_hs_blocks()
assert len(all_bonds) == len(hrsk.all_bonds)
- assert (all_bonds - hrsk.all_bonds < 1e-6).all()
+ # assert (all_bonds - hrsk.all_bonds < 1e-6).all()
assert len(hoppings) == len(hrsk.hamil_blocks)
assert len(overlaps) == len(hrsk.overlap_blocks)
assert len(hrsk.hamil_blocks) == len(hrsk.overlap_blocks)
diff --git a/dptb/tests/test_index_map.py b/dptb/v1/v1test/_test_index_map.py
similarity index 100%
rename from dptb/tests/test_index_map.py
rename to dptb/v1/v1test/_test_index_map.py
diff --git a/dptb/tests/test_integralFunc.py b/dptb/v1/v1test/_test_integralFunc.py
similarity index 100%
rename from dptb/tests/test_integralFunc.py
rename to dptb/v1/v1test/_test_integralFunc.py
diff --git a/dptb/tests/test_make_kpoints.py b/dptb/v1/v1test/_test_make_kpoints.py
similarity index 100%
rename from dptb/tests/test_make_kpoints.py
rename to dptb/v1/v1test/_test_make_kpoints.py
diff --git a/dptb/tests/test_negf_density_Ozaki.py b/dptb/v1/v1test/_test_negf_density_Ozaki.py
similarity index 97%
rename from dptb/tests/test_negf_density_Ozaki.py
rename to dptb/v1/v1test/_test_negf_density_Ozaki.py
index bbec768f..b0eb8de5 100644
--- a/dptb/tests/test_negf_density_Ozaki.py
+++ b/dptb/v1/v1test/_test_negf_density_Ozaki.py
@@ -1,9 +1,9 @@
# test_negf_density_Ozaki
from dptb.negf.density import Ozaki
from dptb.negf.device_property import DeviceProperty
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost
from dptb.utils.tools import j_must_have
from dptb.utils.tools import j_loader
import numpy as np
diff --git a/dptb/tests/test_negf_device_property.py b/dptb/v1/v1test/_test_negf_device_property.py
similarity index 98%
rename from dptb/tests/test_negf_device_property.py
rename to dptb/v1/v1test/_test_negf_device_property.py
index 9a711fa9..cf24e0e4 100644
--- a/dptb/tests/test_negf_device_property.py
+++ b/dptb/v1/v1test/_test_negf_device_property.py
@@ -1,8 +1,8 @@
#test_negf_Device_set_leadLR
from dptb.negf.device_property import DeviceProperty
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost
from dptb.utils.tools import j_must_have
from dptb.utils.tools import j_loader
import numpy as np
diff --git a/dptb/tests/test_negf_negf_hamiltonian_init.py b/dptb/v1/v1test/_test_negf_negf_hamiltonian_init.py
similarity index 97%
rename from dptb/tests/test_negf_negf_hamiltonian_init.py
rename to dptb/v1/v1test/_test_negf_negf_hamiltonian_init.py
index 859cfcc6..13da5abe 100644
--- a/dptb/tests/test_negf_negf_hamiltonian_init.py
+++ b/dptb/v1/v1test/_test_negf_negf_hamiltonian_init.py
@@ -1,7 +1,7 @@
# Hamiltonian
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost
from dptb.utils.tools import j_must_have
from dptb.utils.tools import j_loader
import numpy as np
diff --git a/dptb/tests/test_negf_ozaki_res_cal.py b/dptb/v1/v1test/_test_negf_ozaki_res_cal.py
similarity index 100%
rename from dptb/tests/test_negf_ozaki_res_cal.py
rename to dptb/v1/v1test/_test_negf_ozaki_res_cal.py
diff --git a/dptb/tests/test_negf_recursive_gf_cal.py b/dptb/v1/v1test/_test_negf_recursive_gf_cal.py
similarity index 98%
rename from dptb/tests/test_negf_recursive_gf_cal.py
rename to dptb/v1/v1test/_test_negf_recursive_gf_cal.py
index 564426b6..83b7fdc9 100644
--- a/dptb/tests/test_negf_recursive_gf_cal.py
+++ b/dptb/v1/v1test/_test_negf_recursive_gf_cal.py
@@ -1,8 +1,8 @@
#test_negf_RGF
from dptb.negf.device_property import DeviceProperty
-from dptb.plugins.init_nnsk import InitSKModel
-from dptb.nnops.NN2HRK import NN2HRK
-from dptb.nnops.apihost import NNSKHost
+from dptb.v1.init_nnsk import InitSKModel
+from dptb.nnops.v1.NN2HRK import NN2HRK
+from dptb.nnops.v1.apihost import NNSKHost
from dptb.utils.tools import j_must_have
from dptb.utils.tools import j_loader
import numpy as np
diff --git a/dptb/tests/test_negf_run.py b/dptb/v1/v1test/_test_negf_run.py
similarity index 100%
rename from dptb/tests/test_negf_run.py
rename to dptb/v1/v1test/_test_negf_run.py
diff --git a/dptb/tests/test_nntb.py b/dptb/v1/v1test/_test_nntb.py
similarity index 100%
rename from dptb/tests/test_nntb.py
rename to dptb/v1/v1test/_test_nntb.py
diff --git a/dptb/tests/test_onsiteDB.py b/dptb/v1/v1test/_test_onsiteDB.py
similarity index 100%
rename from dptb/tests/test_onsiteDB.py
rename to dptb/v1/v1test/_test_onsiteDB.py
diff --git a/dptb/tests/test_onsiteFunc.py b/dptb/v1/v1test/_test_onsiteFunc.py
similarity index 100%
rename from dptb/tests/test_onsiteFunc.py
rename to dptb/v1/v1test/_test_onsiteFunc.py
diff --git a/dptb/tests/test_onsite_formula.py b/dptb/v1/v1test/_test_onsite_formula.py
similarity index 100%
rename from dptb/tests/test_onsite_formula.py
rename to dptb/v1/v1test/_test_onsite_formula.py
diff --git a/dptb/tests/test_process_wannier.py b/dptb/v1/v1test/_test_process_wannier.py
similarity index 100%
rename from dptb/tests/test_process_wannier.py
rename to dptb/v1/v1test/_test_process_wannier.py
diff --git a/dptb/tests/test_processor.py b/dptb/v1/v1test/_test_processor.py
similarity index 100%
rename from dptb/tests/test_processor.py
rename to dptb/v1/v1test/_test_processor.py
diff --git a/dptb/tests/test_readdata.py b/dptb/v1/v1test/_test_readdata.py
similarity index 100%
rename from dptb/tests/test_readdata.py
rename to dptb/v1/v1test/_test_readdata.py
diff --git a/dptb/tests/test_skIntegrals.py b/dptb/v1/v1test/_test_skIntegrals.py
similarity index 100%
rename from dptb/tests/test_skIntegrals.py
rename to dptb/v1/v1test/_test_skIntegrals.py
diff --git a/dptb/tests/test_skParam.py b/dptb/v1/v1test/_test_skParam.py
similarity index 100%
rename from dptb/tests/test_skParam.py
rename to dptb/v1/v1test/_test_skParam.py
diff --git a/dptb/tests/test_skformula.py b/dptb/v1/v1test/_test_skformula.py
similarity index 100%
rename from dptb/tests/test_skformula.py
rename to dptb/v1/v1test/_test_skformula.py
diff --git a/dptb/tests/test_skintTypes.py b/dptb/v1/v1test/_test_skintTypes.py
similarity index 100%
rename from dptb/tests/test_skintTypes.py
rename to dptb/v1/v1test/_test_skintTypes.py
diff --git a/dptb/tests/test_sknet.py b/dptb/v1/v1test/_test_sknet.py
similarity index 100%
rename from dptb/tests/test_sknet.py
rename to dptb/v1/v1test/_test_sknet.py
diff --git a/dptb/tests/test_socDB.py b/dptb/v1/v1test/_test_socDB.py
similarity index 100%
rename from dptb/tests/test_socDB.py
rename to dptb/v1/v1test/_test_socDB.py
diff --git a/dptb/tests/test_socFunc.py b/dptb/v1/v1test/_test_socFunc.py
similarity index 100%
rename from dptb/tests/test_socFunc.py
rename to dptb/v1/v1test/_test_socFunc.py
diff --git a/dptb/tests/test_socmat.py b/dptb/v1/v1test/_test_socmat.py
similarity index 100%
rename from dptb/tests/test_socmat.py
rename to dptb/v1/v1test/_test_socmat.py
diff --git a/dptb/tests/test_struct_skhs.py b/dptb/v1/v1test/_test_struct_skhs.py
similarity index 100%
rename from dptb/tests/test_struct_skhs.py
rename to dptb/v1/v1test/_test_struct_skhs.py
diff --git a/dptb/tests/test_structure.py b/dptb/v1/v1test/_test_structure.py
similarity index 100%
rename from dptb/tests/test_structure.py
rename to dptb/v1/v1test/_test_structure.py
diff --git a/dptb/tests/_test_tbnet_emb.py b/dptb/v1/v1test/_test_tbnet_emb.py
similarity index 100%
rename from dptb/tests/_test_tbnet_emb.py
rename to dptb/v1/v1test/_test_tbnet_emb.py
diff --git a/dptb/tests/_test_tbnet_hoppings.py b/dptb/v1/v1test/_test_tbnet_hoppings.py
similarity index 100%
rename from dptb/tests/_test_tbnet_hoppings.py
rename to dptb/v1/v1test/_test_tbnet_hoppings.py
diff --git a/dptb/tests/_test_tbnet_onsite.py b/dptb/v1/v1test/_test_tbnet_onsite.py
similarity index 100%
rename from dptb/tests/_test_tbnet_onsite.py
rename to dptb/v1/v1test/_test_tbnet_onsite.py
diff --git a/dptb/tests/test_transform_sk.py b/dptb/v1/v1test/_test_transform_sk.py
similarity index 100%
rename from dptb/tests/test_transform_sk.py
rename to dptb/v1/v1test/_test_transform_sk.py
diff --git a/dptb/tests/input.json b/dptb/v1/v1test/input.json
similarity index 100%
rename from dptb/tests/input.json
rename to dptb/v1/v1test/input.json
diff --git a/examples/e3/input.json b/examples/e3/input.json
new file mode 100644
index 00000000..1c6cacfa
--- /dev/null
+++ b/examples/e3/input.json
@@ -0,0 +1,67 @@
+{
+ "common_options": {
+ "bond_cutoff": 5.0,
+ "env_cutoff": 5.0,
+ "seed": 12342,
+ "basis": {
+ "Al": ["3s", "3p", "d*"],
+ "As": ["4s", "4p", "d*"]
+ },
+ "device": "cuda",
+ "dtype": "float32",
+ "overlap": false
+ },
+ "model_options": {
+ "embedding":{
+ "method": "se2",
+ "rc": 5.0,
+ "rs": 2.0,
+ "n_axis": 10,
+ "radial_net": {
+ "neurons": [20,40,60],
+ "activation": "tanh",
+ "if_batch_normalized": false
+ }
+ },
+ "prediction":{
+ "method": "sktb",
+ "neurons": [128,128,128],
+ "activation": "tanh",
+ "if_batch_normalized": false
+ }
+ },
+ "train_options": {
+ "num_epoch": 4000,
+ "batch_size": 1,
+ "optimizer": {
+ "lr": 0.01,
+ "type": "Adam"
+ },
+ "lr_scheduler": {
+ "type": "exp",
+ "gamma": 0.995
+ },
+ "loss_options":{
+ "train":{"method": "eigvals"}
+ },
+ "save_freq": 10,
+ "validation_freq": 10,
+ "display_freq": 1
+ },
+ "data_options": {
+ "train": {
+ "root": "/share/semicond/lmp_abacus/abacus_hse_data/AlAs/result-prod-alas/prod-alas/AlAs/sys-000/",
+ "preprocess_path": "/share/semicond/lmp_abacus/abacus_hse_data/AlAs/result-prod-alas/prod-alas/AlAs/sys-000/atomic_data/",
+ "file_names": [
+ "T100/frame-29/AtomicData.h5",
+ "T500/frame-100/AtomicData.h5",
+ "T500/frame-44/AtomicData.h5",
+ "T1000/frame-27/AtomicData.h5",
+ "T1000/frame-52/AtomicData.h5",
+ "T1500/frame-35/AtomicData.h5",
+ "T1500/frame-89/AtomicData.h5"
+ ],
+ "pbc": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/examples/silicon/ifermi.ipynb b/examples/silicon/ifermi.ipynb
index 0604b76f..55073a89 100644
--- a/examples/silicon/ifermi.ipynb
+++ b/examples/silicon/ifermi.ipynb
@@ -629582,7 +629582,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.6"
+ "version": "3.8.13"
},
"orig_nbformat": 4
},
diff --git a/pyproject.toml b/pyproject.toml
index 49a9d62c..5638975b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,6 +21,12 @@ future = "*"
dargs = "0.3.3"
xitorch = "0.3.0"
fmm3dpy = "1.0.0"
+e3nn = ">=0.5.1"
+torch-runstats = "0.2.0"
+torch_scatter = "2.1.2"
+torch_geometric = ">=2.4.0"
+opt-einsum = "3.3.0"
+
[tool.poetry.group.dev.dependencies]
pytest = ">=7.2.0"