deepmd.pt_expt.descriptor

deepmd.pt_expt.descriptor#

Submodules#

Attributes#

BaseDescriptor

Classes#

`DescrptDPA1`	Attention-based descriptor which is proposed in the pretrainable DPA-1[1] model.
`DescrptDPA2`	The DPA-2 descriptor[Rf0ed3afb961b-1]_.
`DescrptDPA3`	The DPA3 descriptor[Rfbfb621257be-1]_.
`DescrptHybrid`	Concatenate a list of descriptors to form a new descriptor.
`DescrptSeAttenV2`	Attention-based descriptor (version 2) which uses stripped type embedding.
`DescrptSeA`	DeepPot-SE constructed from all information (both angular and radial) of
`DescrptSeR`	DeepPot-SE_R constructed from only the radial information of atomic configurations.
`DescrptSeT`	DeepPot-SE constructed from all information (both angular and radial) of atomic
`DescrptSeTTebd`	Construct an embedding net that takes angles between two neighboring atoms and type embeddings as input.

Package Contents#

deepmd.pt_expt.descriptor.BaseDescriptor[source]#

class deepmd.pt_expt.descriptor.DescrptDPA1(rcut: float, rcut_smth: float, sel: list[int] | int, ntypes: int, neuron: list[int] = [25, 50, 100], axis_neuron: int = 8, tebd_dim: int = 8, tebd_input_mode: str = 'concat', resnet_dt: bool = False, trainable: bool = True, type_one_side: bool = False, attn: int = 128, attn_layer: int = 2, attn_dotr: bool = True, attn_mask: bool = False, exclude_types: list[tuple[int, int]] = [], env_protection: float = 0.0, set_davg_zero: bool = False, activation_function: str = 'tanh', precision: str = DEFAULT_PRECISION, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, trainable_ln: bool = True, ln_eps: float | None = 1e-05, smooth_type_embedding: bool = True, concat_output_tebd: bool = True, spin: None = None, stripped_type_embedding: bool | None = None, use_econf_tebd: bool = False, use_tebd_bias: bool = False, type_map: list[str] | None = None, seed: int | list[int] | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.dpa1.DescrptDPA1

Attention-based descriptor which is proposed in the pretrainable DPA-1[1] model.

This descriptor, \(\mathcal{D}^i \in \mathbb{R}^{M \times M_{<}}\), is given by

\[\mathcal{D}^i = \frac{1}{N_c^2}(\hat{\mathcal{G}}^i)^T \mathcal{R}^i (\mathcal{R}^i)^T \hat{\mathcal{G}}^i_<,\]

where \(\hat{\mathcal{G}}^i\) represents the embedding matrix:math:mathcal{G}^i after additional self-attention mechanism and \(\mathcal{R}^i\) is defined by the full case in the se_e2_a descriptor. Note that we obtain \(\mathcal{G}^i\) using the type embedding method by default in this descriptor.

To perform the self-attention mechanism, the queries \(\mathcal{Q}^{i,l} \in \mathbb{R}^{N_c\times d_k}\), keys \(\mathcal{K}^{i,l} \in \mathbb{R}^{N_c\times d_k}\), and values \(\mathcal{V}^{i,l} \in \mathbb{R}^{N_c\times d_v}\) are first obtained:

\[\left(\mathcal{Q}^{i,l}\right)_{j}=Q_{l}\left(\left(\mathcal{G}^{i,l-1}\right)_{j}\right),\]

\[\left(\mathcal{K}^{i,l}\right)_{j}=K_{l}\left(\left(\mathcal{G}^{i,l-1}\right)_{j}\right),\]

\[\left(\mathcal{V}^{i,l}\right)_{j}=V_{l}\left(\left(\mathcal{G}^{i,l-1}\right)_{j}\right),\]

where \(Q_{l}\), \(K_{l}\), \(V_{l}\) represent three trainable linear transformations that output the queries and keys of dimension \(d_k\) and values of dimension \(d_v\), and \(l\) is the index of the attention layer. The input embedding matrix to the attention layers, denoted by \(\mathcal{G}^{i,0}\), is chosen as the two-body embedding matrix.

Then the scaled dot-product attention method is adopted:

\[A(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l}, \mathcal{V}^{i,l}, \mathcal{R}^{i,l})=\varphi\left(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l},\mathcal{R}^{i,l}\right)\mathcal{V}^{i,l},\]

where \(\varphi\left(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l},\mathcal{R}^{i,l}\right) \in \mathbb{R}^{N_c\times N_c}\) is attention weights. In the original attention method, one typically has \(\varphi\left(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l}\right)=\mathrm{softmax}\left(\frac{\mathcal{Q}^{i,l} (\mathcal{K}^{i,l})^{T}}{\sqrt{d_{k}}}\right)\), with \(\sqrt{d_{k}}\) being the normalization temperature. This is slightly modified to incorporate the angular information:

\[\varphi\left(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l},\mathcal{R}^{i,l}\right) = \mathrm{softmax}\left(\frac{\mathcal{Q}^{i,l} (\mathcal{K}^{i,l})^{T}}{\sqrt{d_{k}}}\right) \odot \hat{\mathcal{R}}^{i}(\hat{\mathcal{R}}^{i})^{T},\]

where \(\hat{\mathcal{R}}^{i} \in \mathbb{R}^{N_c\times 3}\) denotes normalized relative coordinates,: \(\hat{\mathcal{R}}^{i}_{j} = \frac{\boldsymbol{r}_{ij}}{\lVert \boldsymbol{r}_{ij} \lVert}\) and \(\odot\) means element-wise multiplication.
Then layer normalization is added in a residual way to finally obtain the self-attention local embedding matrix: \(\hat{\mathcal{G}}^{i} = \mathcal{G}^{i,L_a}\) after \(L_a\) attention layers:[^1]

\[\mathcal{G}^{i,l} = \mathcal{G}^{i,l-1} + \mathrm{LayerNorm}(A(\mathcal{Q}^{i,l}, \mathcal{K}^{i,l}, \mathcal{V}^{i,l}, \mathcal{R}^{i,l})).\]

Parameters:

rcut: float: The cut-off radius \(r_c\)
rcut_smth: float: From where the environment matrix should be smoothed \(r_s\)
sellist[int], int: list[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius int: the total maxmum number of atoms in the cut-off radius
ntypesint: Number of element types
neuronlist[int]: Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
axis_neuron: int: Number of the axis neuron \(M_2\) (number of columns of the sub-matrix of the embedding matrix)
tebd_dim: int: Dimension of the type embedding
tebd_input_mode: str: The input mode of the type embedding. Supported modes are [“concat”, “strip”]. - “concat”: Concatenate the type embedding with the smoothed radial information as the union input for the embedding network. - “strip”: Use a separated embedding network for the type embedding and combine the output with the radial embedding network output.
resnet_dt: bool: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
trainable: bool: If the weights of this descriptors are trainable.
trainable_ln: bool: Whether to use trainable shift and scale weights in layer normalization.
ln_eps: float, Optional: The epsilon value for layer normalization.
type_one_side: bool: If ‘False’, type embeddings of both neighbor and central atoms are considered. If ‘True’, only type embeddings of neighbor atoms are considered. Default is ‘False’.
attn: int: Hidden dimension of the attention vectors
attn_layer: int: Number of attention layers
attn_dotr: bool: If dot the angular gate to the attention weights
attn_mask: bool: (Only support False to keep consistent with other backend references.) (Not used in this version. True option is not implemented.) If mask the diagonal of attention weights
exclude_typeslist[list[int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
env_protection: float: Protection parameter to prevent division by zero errors during environment matrix calculations.
set_davg_zero: bool: Set the shift of embedding net input to zero.
activation_function: str: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
precision: str: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
scaling_factor: float: The scaling factor of normalization in calculations of attention weights. If temperature is None, the scaling of attention weights is (N_dim * scaling_factor)**0.5
normalize: bool: Whether to normalize the hidden vectors in attention weights calculation.
temperature: float: If not None, the scaling of attention weights is temperature itself.
smooth_type_embedding: bool: Whether to use smooth process in attention weights calculation.
concat_output_tebd: bool: Whether to concat type embedding at the output of the descriptor.
stripped_type_embedding: bool, Optional: (Deprecated, kept only for compatibility.) Whether to strip the type embedding into a separate embedding network. Setting this parameter to True is equivalent to setting tebd_input_mode to ‘strip’. Setting it to False is equivalent to setting tebd_input_mode to ‘concat’. The default value is None, which means the tebd_input_mode setting will be used instead.
use_econf_tebd: bool, Optional: Whether to use electronic configuration type embedding.
use_tebd_biasbool, Optional: Whether to use bias in the type embedding layer.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
spin: (Only support None to keep consistent with other backend references.) (Not used in this version. Not-none option is not implemented.) The old implementation of deepspin.

References

[1]

Duo Zhang, Hangrui Bi, Fu-Zhi Dai, Wanrun Jiang, Linfeng Zhang, and Han Wang. 2022. DPA-1: Pretraining of Attention-based Deep Potential Model for Molecular Simulation. arXiv preprint arXiv:2208.08236.

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptDPA2(ntypes: int, repinit: RepinitArgs | dict, repformer: RepformerArgs | dict, concat_output_tebd: bool = True, precision: str = 'float64', smooth: bool = True, exclude_types: list[tuple[int, int]] = [], env_protection: float = 0.0, trainable: bool = True, seed: int | list[int] | None = None, add_tebd_to_repinit_out: bool = False, use_econf_tebd: bool = False, use_tebd_bias: bool = False, type_map: list[str] | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.dpa2.DescrptDPA2

The DPA-2 descriptor[Rf0ed3afb961b-1]_.

The DPA-2 descriptor combines a repinit block and a repformer block to extract atomic representations. The overall descriptor is computed as:

\[\mathcal{D}^i = \mathrm{Repformer}(\mathrm{Linear}(\mathrm{Repinit}(\mathcal{R}^i, \mathcal{T}^i))),\]

where \(\mathcal{R}^i\) is the environment matrix and \(\mathcal{T}^i\) is the type embedding.

The repinit block computes initial node and edge representations using attention-based message passing. The repformer block further refines these representations through multiple layers of graph convolution and attention mechanisms.

The final output dimension is:

\[\dim(\mathcal{D}^i) = \text{g1\_dim} + \text{tebd\_dim} \quad (\text{if concat\_output\_tebd}).\]

Parameters:

repinitUnion[RepinitArgs, dict]: The arguments used to initialize the repinit block, see docstr in RepinitArgs for details information.
repformerUnion[RepformerArgs, dict]: The arguments used to initialize the repformer block, see docstr in RepformerArgs for details information.
concat_output_tebdbool, optional: Whether to concat type embedding at the output of the descriptor.
precisionstr, optional: The precision of the embedding net parameters.
smoothbool, optional: Whether to use smoothness in processes such as attention weights calculation.
exclude_typeslist[list[int]], optional: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
env_protectionfloat, optional: Protection parameter to prevent division by zero errors during environment matrix calculations. For example, when using paddings, there may be zero distances of neighbors, which may make division by zero error during environment matrix calculations without protection.
trainablebool, optional: If the parameters are trainable.
seedint, optional: (Unused yet) Random seed for parameter initialization.
add_tebd_to_repinit_outbool, optional: Whether to add type embedding to the output representation from repinit before inputting it into repformer.
use_econf_tebdbool, Optional: Whether to use electronic configuration type embedding.
use_tebd_biasbool, Optional: Whether to use bias in the type embedding layer.
type_maplist[str], Optional: A list of strings. Give the name to each type of atoms.

Returns:

descriptor: torch.Tensor: the descriptor of shape nf x nloc x g1_dim. invariant single-atom representation.
g2: torch.Tensor: invariant pair-atom representation.
h2: torch.Tensor: equivariant pair-atom representation.
rot_mat: torch.Tensor: rotation matrix for equivariant fittings
sw: torch.Tensor: The switch function for decaying inverse distance.

References

[1]

Zhang, D., Liu, X., Zhang, X. et al. DPA-2: a large atomic model as a multi-task learner. npj Comput Mater 10, 293 (2024). https://doi.org/10.1038/s41524-024-01493-2

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptDPA3(ntypes: int, repflow: RepFlowArgs | dict, concat_output_tebd: bool = False, activation_function: str = 'silu', precision: str = 'float64', exclude_types: list[tuple[int, int]] = [], env_protection: float = 0.0, trainable: bool = True, seed: int | list[int] | None = None, use_econf_tebd: bool = False, use_tebd_bias: bool = False, use_loc_mapping: bool = True, type_map: list[str] | None = None, add_chg_spin_ebd: bool = False)[source]#

Bases: deepmd.dpmodel.descriptor.dpa3.DescrptDPA3

The DPA3 descriptor[Rfbfb621257be-1]_.

The DPA-3 descriptor uses a repflow block to iteratively update node, edge, and angle representations. The descriptor is computed as:

\[\mathcal{D}^i = \mathrm{RepFlow}(\mathcal{N}^i, \mathcal{E}^i, \mathcal{A}^i),\]

where \(\mathcal{N}^i\), \(\mathcal{E}^i\), and \(\mathcal{A}^i\) are the initial node, edge, and angle representations respectively.

The repflow block performs iterative updates through multiple layers:

\[\mathcal{N}^{i,l+1} = \mathrm{UpdateNode}(\mathcal{N}^{i,l}, \mathcal{E}^{i,l}, \mathcal{A}^{i,l}),\]

\[\mathcal{E}^{i,l+1} = \mathrm{UpdateEdge}(\mathcal{N}^{i,l}, \mathcal{E}^{i,l}, \mathcal{A}^{i,l}),\]

\[\mathcal{A}^{i,l+1} = \mathrm{UpdateAngle}(\mathcal{N}^{i,l}, \mathcal{E}^{i,l}, \mathcal{A}^{i,l}).\]

The final descriptor output dimension is:

\[\dim(\mathcal{D}^i) = \text{n\_dim} \times \text{axis\_neuron} \quad (\text{after symmetrization}).\]

Parameters:

repflowUnion[RepFlowArgs, dict]: The arguments used to initialize the repflow block, see docstr in RepFlowArgs for details information.
concat_output_tebdbool, optional: Whether to concat type embedding at the output of the descriptor.
activation_functionstr, optional: The activation function in the embedding net.
precisionstr, optional: The precision of the embedding net parameters.
exclude_typeslist[list[int]], optional: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
env_protectionfloat, optional: Protection parameter to prevent division by zero errors during environment matrix calculations. For example, when using paddings, there may be zero distances of neighbors, which may make division by zero error during environment matrix calculations without protection.
trainablebool, optional: If the parameters are trainable.
seedint, optional: Random seed for parameter initialization.
use_econf_tebdbool, Optional: Whether to use electronic configuration type embedding.
use_tebd_biasbool, Optional: Whether to use bias in the type embedding layer.
use_loc_mappingbool, Optional: Whether to use local atom index mapping in training or non-parallel inference. When True, local indexing and mapping are applied to neighbor lists and embeddings during descriptor computation.
type_maplist[str], Optional: A list of strings. Give the name to each type of atoms.

References

[1]

Zhang, D., Peng, A., Cai, C. et al. Graph neural network model for the era of large atomistic models. arXiv preprint arXiv:2506.01686 (2025).

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptHybrid(list: DescrptHybrid.__init__.list[deepmd.dpmodel.descriptor.base_descriptor.BaseDescriptor | dict[str, Any]], type_map: DescrptHybrid.__init__.list[str] | None = None, ntypes: int | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.hybrid.DescrptHybrid

Concatenate a list of descriptors to form a new descriptor.

The hybrid descriptor combines multiple descriptors by concatenation:

\[\mathcal{D}^i = [\mathcal{D}^i_1, \mathcal{D}^i_2, ..., \mathcal{D}^i_n],\]

where \(\mathcal{D}^i_k\) is the descriptor computed by the \(k\)-th sub-descriptor for atom \(i\).

The output dimension is the sum of all sub-descriptor dimensions:

\[\dim(\mathcal{D}^i) = \sum_{k=1}^{n} \dim(\mathcal{D}^i_k).\]

Parameters:

listlistlist[Union[BaseDescriptor, dict[str, Any]]]: Build a descriptor from the concatenation of the list of descriptors. The descriptor can be either an object or a dictionary.

class deepmd.pt_expt.descriptor.DescrptSeAttenV2(rcut: float, rcut_smth: float, sel: list[int] | int, ntypes: int, neuron: list[int] = [25, 50, 100], axis_neuron: int = 8, tebd_dim: int = 8, resnet_dt: bool = False, trainable: bool = True, type_one_side: bool = False, attn: int = 128, attn_layer: int = 2, attn_dotr: bool = True, attn_mask: bool = False, exclude_types: list[tuple[int, int]] = [], env_protection: float = 0.0, set_davg_zero: bool = False, activation_function: str = 'tanh', precision: str = DEFAULT_PRECISION, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, trainable_ln: bool = True, ln_eps: float | None = 1e-05, concat_output_tebd: bool = True, spin: Any | None = None, stripped_type_embedding: bool | None = None, use_econf_tebd: bool = False, use_tebd_bias: bool = False, type_map: list[str] | None = None, seed: int | list[int] | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.se_atten_v2.DescrptSeAttenV2

Attention-based descriptor (version 2) which uses stripped type embedding.

This descriptor inherits from DescrptDPA1 and uses the same attention-based mechanism, but with tebd_input_mode=”strip” by default. The descriptor \(\mathcal{D}^i \in \mathbb{R}^{M \times M_{<}}\) is computed as:

\[\mathcal{D}^i = \frac{1}{N_c^2}(\hat{\mathcal{G}}^i)^T \mathcal{R}^i (\mathcal{R}^i)^T \hat{\mathcal{G}}^i_<,\]

where \(\hat{\mathcal{G}}^i\) is the embedding matrix after self-attention layers, and \(\mathcal{R}^i\) is the coordinate matrix (see DescrptDPA1 for details).

The key difference from DPA-1 is that the type embedding is processed by a separate embedding network and combined multiplicatively with the radial embedding:

\[\mathcal{G}^i = \mathcal{N}_r(s(r)) \odot \mathcal{N}_t(\mathcal{T}) + \mathcal{N}_r(s(r)),\]

where \(\mathcal{N}_r\) is the radial embedding network, \(\mathcal{N}_t\) is the type embedding network, and \(\odot\) denotes element-wise multiplication.

Parameters:

rcut: float: The cut-off radius \(r_c\)
rcut_smth: float: From where the environment matrix should be smoothed \(r_s\)
sellist[int], int: list[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius int: the total maxmum number of atoms in the cut-off radius
ntypesint: Number of element types
neuronlist[int]: Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
axis_neuron: int: Number of the axis neuron \(M_2\) (number of columns of the sub-matrix of the embedding matrix)
tebd_dim: int: Dimension of the type embedding
resnet_dt: bool: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
trainable: bool: If the weights of this descriptors are trainable.
trainable_ln: bool: Whether to use trainable shift and scale weights in layer normalization.
ln_eps: float, Optional: The epsilon value for layer normalization.
type_one_side: bool: If ‘False’, type embeddings of both neighbor and central atoms are considered. If ‘True’, only type embeddings of neighbor atoms are considered. Default is ‘False’.
attn: int: Hidden dimension of the attention vectors
attn_layer: int: Number of attention layers
attn_dotr: bool: If dot the angular gate to the attention weights
attn_mask: bool: (Only support False to keep consistent with other backend references.) (Not used in this version. True option is not implemented.) If mask the diagonal of attention weights
exclude_typeslist[list[int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
env_protection: float: Protection parameter to prevent division by zero errors during environment matrix calculations.
set_davg_zero: bool: Set the shift of embedding net input to zero.
activation_function: str: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
precision: str: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
scaling_factor: float: The scaling factor of normalization in calculations of attention weights. If temperature is None, the scaling of attention weights is (N_dim * scaling_factor)**0.5
normalize: bool: Whether to normalize the hidden vectors in attention weights calculation.
temperature: float: If not None, the scaling of attention weights is temperature itself.
concat_output_tebd: bool: Whether to concat type embedding at the output of the descriptor.
use_econf_tebd: bool, Optional: Whether to use electronic configuration type embedding.
use_tebd_biasbool, Optional: Whether to use bias in the type embedding layer.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
seedint, Optional: Random seed for initializing the network parameters.

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptSeA(rcut: float, rcut_smth: float, sel: list[int], neuron: list[int] = [24, 48, 96], axis_neuron: int = 8, resnet_dt: bool = False, trainable: bool = True, type_one_side: bool = True, exclude_types: list[list[int]] = [], env_protection: float = 0.0, set_davg_zero: bool = False, activation_function: str = 'tanh', precision: str = DEFAULT_PRECISION, spin: Any | None = None, type_map: list[str] | None = None, ntypes: int | None = None, seed: int | list[int] | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.se_e2_a.DescrptSeA

DeepPot-SE constructed from all information (both angular and radial) of atomic configurations. The embedding takes the distance between atoms as input.

The descriptor \(\mathcal{D}^i \in \mathcal{R}^{M_1 \times M_2}\) is given by [1]

\[\mathcal{D}^i = (\mathcal{G}^i)^T \mathcal{R}^i (\mathcal{R}^i)^T \mathcal{G}^i_<\]

where \(\mathcal{R}^i \in \mathbb{R}^{N \times 4}\) is the coordinate matrix, and each row of \(\mathcal{R}^i\) can be constructed as follows

\[(\mathcal{R}^i)_j = [ \begin{array}{c} s(r_{ji}) & \frac{s(r_{ji})x_{ji}}{r_{ji}} & \frac{s(r_{ji})y_{ji}}{r_{ji}} & \frac{s(r_{ji})z_{ji}}{r_{ji}} \end{array} ]\]

where \(\mathbf{R}_{ji}=\mathbf{R}_j-\mathbf{R}_i = (x_{ji}, y_{ji}, z_{ji})\) is the relative coordinate and \(r_{ji}=\lVert \mathbf{R}_{ji} \lVert\) is its norm. The switching function \(s(r)\) is defined as:

\[\begin{split}s(r)= \begin{cases} \frac{1}{r}, & r<r_s \\ \frac{1}{r} \{ {(\frac{r - r_s}{ r_c - r_s})}^3 (-6 {(\frac{r - r_s}{ r_c - r_s})}^2 +15 \frac{r - r_s}{ r_c - r_s} -10) +1 \}, & r_s \leq r<r_c \\ 0, & r \geq r_c \end{cases}\end{split}\]

Each row of the embedding matrix \(\mathcal{G}^i \in \mathbb{R}^{N \times M_1}\) consists of outputs of a embedding network \(\mathcal{N}\) of \(s(r_{ji})\):

\[(\mathcal{G}^i)_j = \mathcal{N}(s(r_{ji}))\]

\(\mathcal{G}^i_< \in \mathbb{R}^{N \times M_2}\) takes first \(M_2\) columns of \(\mathcal{G}^i\). The equation of embedding network \(\mathcal{N}\) can be found at deepmd.tf.utils.network.embedding_net().

Parameters:

rcut: The cut-off radius \(r_c\)
rcut_smth: From where the environment matrix should be smoothed \(r_s\)
sellist[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius
neuronlist[int]: Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
axis_neuron: Number of the axis neuron \(M_2\) (number of columns of the sub-matrix of the embedding matrix)
resnet_dt: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
trainable: If the weights of embedding net are trainable.
type_one_side: Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
exclude_typeslist[list[int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
env_protection: float: Protection parameter to prevent division by zero errors during environment matrix calculations.
set_davg_zero: Set the shift of embedding net input to zero.
activation_function: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
precision: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
spin: The deepspin object.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
ntypesint: Number of element types. Not used in this descriptor, only to be compat with input.

References

[1]

Linfeng Zhang, Jiequn Han, Han Wang, Wissam A. Saidi, Roberto Car, and E. Weinan. 2018. End-to-end symmetry preserving inter-atomic potential energy model for finite and extended systems. In Proceedings of the 32nd International Conference on Neural Information Processing Systems (NIPS’18). Curran Associates Inc., Red Hook, NY, USA, 4441-4451.

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptSeR(rcut: float, rcut_smth: float, sel: list[int], neuron: list[int] = [24, 48, 96], resnet_dt: bool = False, trainable: bool = True, type_one_side: bool = True, exclude_types: list[list[int]] = [], env_protection: float = 0.0, set_davg_zero: bool = False, activation_function: str = 'tanh', precision: str = DEFAULT_PRECISION, spin: Any | None = None, type_map: list[str] | None = None, ntypes: int | None = None, seed: int | list[int] | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.se_r.DescrptSeR

DeepPot-SE_R constructed from only the radial information of atomic configurations.

The descriptor \(\mathcal{D}^i \in \mathbb{R}^{M}\) is given by

\[\mathcal{D}^i = \frac{1}{N_c} \sum_{j=1}^{N_c} \mathcal{N}(s(r_{ji})),\]

where \(\mathcal{N}\) is the embedding network, and \(s(r_{ji})\) is the smoothed radial distance between atom \(i\) and its neighbor \(j\).

The switching function \(s(r)\) is defined as:

\[\begin{split}s(r)= \begin{cases} \frac{1}{r}, & r<r_s \\ \frac{1}{r} \{ {(\frac{r - r_s}{ r_c - r_s})}^3 (-6 {(\frac{r - r_s}{ r_c - r_s})}^2 +15 \frac{r - r_s}{ r_c - r_s} -10) +1 \}, & r_s \leq r<r_c \\ 0, & r \geq r_c \end{cases}\end{split}\]

where \(r_c\) is the cutoff radius and \(r_s\) is the smooth cutoff parameter.

Parameters:

rcut: The cut-off radius \(r_c\)
rcut_smth: From where the environment matrix should be smoothed \(r_s\)
sellist[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius
neuronlist[int]: Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
resnet_dt: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
trainable: If the weights of embedding net are trainable.
type_one_side: Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
exclude_typeslist[list[int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
set_davg_zero: Set the shift of embedding net input to zero.
activation_function: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
precision: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
spin: The deepspin object.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
ntypesint: Number of element types. Not used in this descriptor, only to be compat with input.

References

[1]

Linfeng Zhang, Jiequn Han, Han Wang, Wissam A. Saidi, Roberto Car, and E. Weinan. 2018. End-to-end symmetry preserving inter-atomic potential energy model for finite and extended systems. In Proceedings of the 32nd International Conference on Neural Information Processing Systems (NIPS’18). Curran Associates Inc., Red Hook, NY, USA, 4441-4451.

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptSeT(rcut: float, rcut_smth: float, sel: list[int], neuron: list[int] = [24, 48, 96], resnet_dt: bool = False, set_davg_zero: bool = False, activation_function: str = 'tanh', env_protection: float = 0.0, exclude_types: list[tuple[int, int]] = [], precision: str = DEFAULT_PRECISION, trainable: bool = True, seed: int | list[int] | None = None, type_map: list[str] | None = None, ntypes: int | None = None)[source]#

Bases: deepmd.dpmodel.descriptor.se_t.DescrptSeT

DeepPot-SE constructed from all information (both angular and radial) of atomic configurations.

The embedding takes angles between two neighboring atoms as input.

The descriptor \(\mathcal{D}^i \in \mathbb{R}^{M}\) is given by

\[\mathcal{D}^i = \sum_{t_j, t_k} \frac{1}{N_{t_j} N_{t_k}} \sum_{j \in t_j, k \in t_k} \tilde{g}_{jk} \, \mathcal{N}_{t_j, t_k}(\tilde{g}_{jk}),\]

where \(\tilde{g}_{jk} = \boldsymbol{rr}_j \cdot \boldsymbol{rr}_k\) is the dot product of the smoothed directional vectors from the environment matrix, \(N_{t_j}\) and \(N_{t_k}\) are the numbers of neighbors of types \(t_j\) and \(t_k\), and \(\mathcal{N}_{t_j, t_k}\) is the embedding network that depends only on the types of neighbor atoms \(j\) and \(k\).

The smoothed directional vector \(\boldsymbol{rr}_j\) is computed as:

\[\boldsymbol{rr}_j = s(r_{ji}) \frac{\boldsymbol{R}_j - \boldsymbol{R}_i}{r_{ji}},\]

where \(s(r)\) is the switching function.

Parameters:

rcutfloat: The cut-off radius
rcut_smthfloat: From where the environment matrix should be smoothed
sellist[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius
neuronlist[int]: Number of neurons in each hidden layers of the embedding net
resnet_dtbool: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
set_davg_zerobool: Set the shift of embedding net input to zero.
activation_functionstr: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
env_protectionfloat: Protection parameter to prevent division by zero errors during environment matrix calculations.
exclude_typeslist[list[int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
precisionstr: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
trainablebool: If the weights of embedding net are trainable.
seedint, Optional: Random seed for initializing the network parameters.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
ntypesint: Number of element types. Not used in this descriptor, only to be compat with input.

_update_sel_cls#

class deepmd.pt_expt.descriptor.DescrptSeTTebd(rcut: float, rcut_smth: float, sel: list[int] | int, ntypes: int, neuron: list = [2, 4, 8], tebd_dim: int = 8, tebd_input_mode: str = 'concat', resnet_dt: bool = False, set_davg_zero: bool = True, activation_function: str = 'tanh', env_protection: float = 0.0, exclude_types: list[tuple[int, int]] = [], precision: str = 'float64', trainable: bool = True, seed: int | list[int] | None = None, type_map: list[str] | None = None, concat_output_tebd: bool = True, use_econf_tebd: bool = False, use_tebd_bias: bool = False, smooth: bool = True)[source]#

Bases: deepmd.dpmodel.descriptor.se_t_tebd.DescrptSeTTebd

Construct an embedding net that takes angles between two neighboring atoms and type embeddings as input.

The descriptor \(\mathcal{D}^i \in \mathbb{R}^{M}\) is given by

\[\mathcal{D}^i = \frac{1}{N_c^2} \sum_{j,k} \mathcal{N}(\cos\theta_{jik}, \mathcal{T}_j, \mathcal{T}_k),\]

where \(\theta_{jik}\) is the angle between neighbors \(j\) and \(k\) around the central atom \(i\), \(\mathcal{T}_j\) and \(\mathcal{T}_k\) are the type embeddings of atoms \(j\) and \(k\), and \(\mathcal{N}\) is the embedding network.

The cosine of the angle is computed from the normalized relative coordinates:

\[\cos\theta_{jik} = \frac{\boldsymbol{r}_{ij} \cdot \boldsymbol{r}_{ik}}{|\boldsymbol{r}_{ij}| |\boldsymbol{r}_{ik}|}.\]

The type embedding can be incorporated in two modes:

“concat”: Concatenate \([\cos\theta_{jik}, \mathcal{T}_j, \mathcal{T}_k]\) as input to the embedding network.
“strip”: Use separate embedding networks for \(\cos\theta_{jik}\) and \([\mathcal{T}_j, \mathcal{T}_k]\), then combine their outputs multiplicatively.

Parameters:

rcut: The cut-off radius
rcut_smth: From where the environment matrix should be smoothed
selUnion[list[int], int]: list[int]: sel[i] specifies the maxmum number of type i atoms in the cut-off radius int: the total maxmum number of atoms in the cut-off radius
ntypesint: Number of element types
neuronlist[int]: Number of neurons in each hidden layers of the embedding net
tebd_dimint: Dimension of the type embedding
tebd_input_modestr: The input mode of the type embedding. Supported modes are [“concat”, “strip”]. - “concat”: Concatenate the type embedding with the smoothed angular information as the union input for the embedding network. - “strip”: Use a separated embedding network for the type embedding and combine the output with the angular embedding network output.
resnet_dt: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
set_davg_zero: Set the shift of embedding net input to zero.
activation_function: The activation function in the embedding net. Supported options are “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
env_protection: float: Protection parameter to prevent division by zero errors during environment matrix calculations.
exclude_typeslist[tuple[int, int]]: The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
precision: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
trainable: If the weights of embedding net are trainable.
seed: Random seed for initializing the network parameters.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.
concat_output_tebd: bool: Whether to concat type embedding at the output of the descriptor.
use_econf_tebd: bool, Optional: Whether to use electronic configuration type embedding.
use_tebd_biasbool, Optional: Whether to use bias in the type embedding layer.
smooth: bool: Whether to use smooth process in calculation.

_update_sel_cls#