deepmd.pt.model.descriptor.se_atten

deepmd.pt.model.descriptor.se_atten#

Classes#

`DescrptBlockSeAtten`	The building block of descriptor.
`NeighborGatedAttention`	Base class for all neural network modules.
`NeighborGatedAttentionLayer`	Base class for all neural network modules.
`GatedAttentionLayer`	Base class for all neural network modules.

Functions#

tabulate_fusion_se_atten(→ list[torch.Tensor])

Module Contents#

deepmd.pt.model.descriptor.se_atten.tabulate_fusion_se_atten(argument0: torch.Tensor, argument1: torch.Tensor, argument2: torch.Tensor, argument3: torch.Tensor, argument4: torch.Tensor, argument5: int, argument6: bool) → list[torch.Tensor][source]#

class deepmd.pt.model.descriptor.se_atten.DescrptBlockSeAtten(rcut: float, rcut_smth: float, sel: list[int] | int, ntypes: int, neuron: list = [25, 50, 100], axis_neuron: int = 16, tebd_dim: int = 8, tebd_input_mode: str = 'concat', set_davg_zero: bool = True, attn: int = 128, attn_layer: int = 2, attn_dotr: bool = True, attn_mask: bool = False, activation_function: str = 'tanh', precision: str = 'float64', resnet_dt: bool = False, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, smooth: bool = True, type_one_side: bool = False, exclude_types: list[tuple[int, int]] = [], env_protection: float = 0.0, trainable_ln: bool = True, ln_eps: float | None = 1e-05, seed: int | list[int] | None = None, type: str | None = None, trainable: bool = True)[source]#

Bases: deepmd.pt.model.descriptor.descriptor.DescriptorBlock

The building block of descriptor. Given the input descriptor, provide with the atomic coordinates, atomic types and neighbor list, calculate the new descriptor.

rcut[source]#

rcut_smth[source]#

neuron = [25, 50, 100][source]#

filter_neuron = [25, 50, 100][source]#

axis_neuron = 16[source]#

tebd_dim = 8[source]#

tebd_input_mode = 'concat'[source]#

set_davg_zero = True[source]#

attn_dim = 128[source]#

attn_layer = 2[source]#

attn_dotr = True[source]#

attn_mask = False[source]#

activation_function = 'tanh'[source]#

precision = 'float64'[source]#

prec = Ellipsis[source]#

resnet_dt = False[source]#

scaling_factor = 1.0[source]#

normalize = True[source]#

temperature = None[source]#

smooth = True[source]#

type_one_side = False[source]#

env_protection = 0.0[source]#

trainable_ln = True[source]#

seed = None[source]#

ln_eps = 1e-05[source]#

ntypes[source]#

sel[source]#

sec[source]#

split_sel[source]#

nnei[source]#

ndescrpt[source]#

dpa1_attention[source]#

tebd_dim_input = 8[source]#

filter_layers_strip = None[source]#

filter_layers[source]#

stats = None[source]#

tebd_compress = False[source]#

geo_compress = False[source]#

is_sorted = False[source]#

compress_info[source]#

compress_data[source]#

get_rcut() → float[source]#: Returns the cut-off radius.

get_rcut_smth() → float[source]#: Returns the radius where the neighbor information starts to smoothly decay to 0.

get_nsel() → int[source]#: Returns the number of selected atoms in the cut-off radius.

get_sel() → list[int][source]#: Returns the number of selected atoms for each type.

get_ntypes() → int[source]#: Returns the number of element types.

get_dim_in() → int[source]#: Returns the input dimension.

get_dim_out() → int[source]#: Returns the output dimension.

get_dim_rot_mat_1() → int[source]#: Returns the first dimension of the rotation matrix. The rotation is of shape dim_1 x 3.

get_dim_emb() → int[source]#: Returns the output dimension of embedding.

__setitem__(key: str, value: Any) → None[source]#

__getitem__(key: str) → Any[source]#

mixed_types() → bool[source]#

If true, the descriptor 1. assumes total number of atoms aligned across frames; 2. requires a neighbor list that does not distinguish different atomic types.

If false, the descriptor 1. assumes total number of atoms of each atom type aligned across frames; 2. requires a neighbor list that distinguishes different atomic types.

get_env_protection() → float[source]#: Returns the protection of building environment matrix.

property dim_out: int[source]#: Returns the output dimension of this descriptor.

property dim_in: int[source]#: Returns the atomic input dimension of this descriptor.

property dim_emb: int[source]#: Returns the output dimension of embedding.

compute_input_stats(merged: collections.abc.Callable[[], list[dict]] | list[dict], path: deepmd.utils.path.DPPath | None = None) → None[source]#

Compute the input statistics (e.g. mean and stddev) for the descriptors from packed data.

Parameters:

mergedUnion[Callable[[], list[dict]], list[dict]]

list[dict]: A list of data samples from various data systems.
Each element, merged[i], is a data dictionary containing keys: torch.Tensor originating from the i-th data system.
Callable[[], list[dict]]: A lazy function that returns data samples in the above format
only when needed. Since the sampling process can be slow and memory-intensive, the lazy function helps by only sampling once.

pathOptional[DPPath]

The path to the stat file.

get_stats() → dict[str, deepmd.utils.env_mat_stat.StatItem][source]#: Get the statistics of the descriptor.

reinit_exclude(exclude_types: list[tuple[int, int]] = []) → None[source]#

enable_compression(table_data: dict, table_config: dict, lower: dict, upper: dict) → None[source]#

type_embedding_compression(type_embedding_net: deepmd.pt.model.network.network.TypeEmbedNet) → None[source]#

Enable type embedding compression for strip mode.

Precomputes embedding network outputs for all type combinations: - One-side: (ntypes+1) combinations (neighbor types only) - Two-side: (ntypes+1)² combinations (neighbor x center type pairs)

Parameters:

type_embedding_netTypeEmbedNet: The type embedding network that provides get_full_embedding() method

forward(nlist: torch.Tensor, extended_coord: torch.Tensor, extended_atype: torch.Tensor, extended_atype_embd: torch.Tensor | None = None, mapping: torch.Tensor | None = None, type_embedding: torch.Tensor | None = None) → tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None][source]#

Compute the descriptor.

Parameters:

nlist: The neighbor list. shape: nf x nloc x nnei
extended_coord: The extended coordinates of atoms. shape: nf x (nallx3)
extended_atype: The extended aotm types. shape: nf x nall x nt
extended_atype_embd: The extended type embedding of atoms. shape: nf x nall
mapping: The index mapping, not required by this descriptor.
type_embedding: Full type embeddings. shape: (ntypes+1) x nt Required for stripped type embeddings.

Returns:

result: The descriptor. shape: nf x nloc x (ng x axis_neuron)
g2: The rotationally invariant pair-partical representation. shape: nf x nloc x nnei x ng
h2: The rotationally equivariant pair-partical representation. shape: nf x nloc x nnei x 3
gr: The rotationally equivariant and permutationally invariant single particle representation. shape: nf x nloc x ng x 3
sw: The smooth switch function. shape: nf x nloc x nnei

has_message_passing() → bool[source]#: Returns whether the descriptor block has message passing.

need_sorted_nlist_for_lower() → bool[source]#: Returns whether the descriptor block needs sorted nlist when using forward_lower.

class deepmd.pt.model.descriptor.se_atten.NeighborGatedAttention(layer_num: int, nnei: int, embed_dim: int, hidden_dim: int, dotr: bool = False, do_mask: bool = False, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, trainable_ln: bool = True, ln_eps: float = 1e-05, smooth: bool = True, precision: str = DEFAULT_PRECISION, seed: int | list[int] | None = None, trainable: bool = True)[source]#

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:: training (bool) – Boolean represents whether this module is in training or evaluation mode.

layer_num[source]#

nnei[source]#

embed_dim[source]#

hidden_dim[source]#

dotr = False[source]#

do_mask = False[source]#

scaling_factor = 1.0[source]#

normalize = True[source]#

temperature = None[source]#

trainable_ln = True[source]#

ln_eps = 1e-05[source]#

smooth = True[source]#

precision = 'float64'[source]#

seed = None[source]#

network_type[source]#

attention_layers[source]#

forward(input_G: torch.Tensor, nei_mask: torch.Tensor, input_r: torch.Tensor | None = None, sw: torch.Tensor | None = None) → torch.Tensor[source]#

Compute the multi-layer gated self-attention.

Parameters:

input_G: inputs with shape: (nf x nloc) x nnei x embed_dim.
nei_mask: neighbor mask, with paddings being 0. shape: (nf x nloc) x nnei.
input_r: normalized radial. shape: (nf x nloc) x nnei x 3.
sw: The smooth switch function. shape: nf x nloc x nnei

__getitem__(key: int) → Any[source]#

__setitem__(key: int, value: Any) → None[source]#

serialize() → dict[source]#

Serialize the networks to a dict.

Returns:

dict: The serialized networks.

classmethod deserialize(data: dict) → NeighborGatedAttention[source]#

Deserialize the networks from a dict.

Parameters:

datadict: The dict to deserialize from.

class deepmd.pt.model.descriptor.se_atten.NeighborGatedAttentionLayer(nnei: int, embed_dim: int, hidden_dim: int, dotr: bool = False, do_mask: bool = False, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, smooth: bool = True, trainable_ln: bool = True, ln_eps: float = 1e-05, precision: str = DEFAULT_PRECISION, seed: int | list[int] | None = None, trainable: bool = True)[source]#

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:: training (bool) – Boolean represents whether this module is in training or evaluation mode.

nnei[source]#

embed_dim[source]#

hidden_dim[source]#

dotr = False[source]#

do_mask = False[source]#

scaling_factor = 1.0[source]#

normalize = True[source]#

temperature = None[source]#

precision = 'float64'[source]#

trainable_ln = True[source]#

ln_eps = 1e-05[source]#

seed = None[source]#

attention_layer[source]#

attn_layer_norm[source]#

forward(x: torch.Tensor, nei_mask: torch.Tensor, input_r: torch.Tensor | None = None, sw: torch.Tensor | None = None) → torch.Tensor[source]#

serialize() → dict[source]#

Serialize the networks to a dict.

Returns:

dict: The serialized networks.

classmethod deserialize(data: dict) → NeighborGatedAttentionLayer[source]#

Deserialize the networks from a dict.

Parameters:

datadict: The dict to deserialize from.

class deepmd.pt.model.descriptor.se_atten.GatedAttentionLayer(nnei: int, embed_dim: int, hidden_dim: int, num_heads: int = 1, dotr: bool = False, do_mask: bool = False, scaling_factor: float = 1.0, normalize: bool = True, temperature: float | None = None, bias: bool = True, smooth: bool = True, precision: str = DEFAULT_PRECISION, seed: int | list[int] | None = None, trainable: bool = True)[source]#

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:: training (bool) – Boolean represents whether this module is in training or evaluation mode.

nnei[source]#

embed_dim[source]#

hidden_dim[source]#

num_heads = 1[source]#

head_dim[source]#

dotr = False[source]#

do_mask = False[source]#

bias = True[source]#

smooth = True[source]#

scaling_factor = 1.0[source]#

temperature = None[source]#

precision = 'float64'[source]#

seed = None[source]#

scaling[source]#

normalize = True[source]#

in_proj[source]#

out_proj[source]#

forward(query: torch.Tensor, nei_mask: torch.Tensor, input_r: torch.Tensor | None = None, sw: torch.Tensor | None = None, attnw_shift: float = 20.0) → tuple[torch.Tensor, torch.Tensor][source]#

Compute the multi-head gated self-attention.

Parameters:

query: inputs with shape: (nf x nloc) x nnei x embed_dim.
nei_mask: neighbor mask, with paddings being 0. shape: (nf x nloc) x nnei.
input_r: normalized radial. shape: (nf x nloc) x nnei x 3.
sw: The smooth switch function. shape: (nf x nloc) x nnei
attnw_shiftfloat: The attention weight shift to preserve smoothness when doing padding before softmax.

serialize() → dict[source]#

Serialize the networks to a dict.

Returns:

dict: The serialized networks.

classmethod deserialize(data: dict) → GatedAttentionLayer[source]#

Deserialize the networks from a dict.

Parameters:

datadict: The dict to deserialize from.