deepmd.tf.fit.dipole

deepmd.tf.fit.dipole#

Classes#

DipoleFittingSeA

Fit the atomic dipole with descriptor se_a.

Module Contents#

class deepmd.tf.fit.dipole.DipoleFittingSeA(ntypes: int, dim_descrpt: int, embedding_width: int, neuron: list[int] = [120, 120, 120], resnet_dt: bool = True, numb_fparam: int = 0, numb_aparam: int = 0, sel_type: list[int] | None = None, seed: int | None = None, activation_function: str = 'tanh', precision: str = 'default', uniform_seed: bool = False, mixed_types: bool = False, type_map: list[str] | None = None, **kwargs)[source]#

Bases: deepmd.tf.fit.fitting.Fitting

Fit the atomic dipole with descriptor se_a.

Parameters:

ntypes: The ntypes of the descriptor \(\mathcal{D}\)
dim_descrpt: The dimension of the descriptor \(\mathcal{D}\)
embedding_width: The rotation matrix dimension of the descriptor \(\mathcal{D}\)
neuronlist[int]: Number of neurons in each hidden layer of the fitting net
resnet_dtbool: Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
numb_fparam: Number of frame parameters
numb_aparam: Number of atomic parameters
sel_typelist[int]: The atom types selected to have an atomic dipole prediction. If is None, all atoms are selected.
seedint: Random seed for initializing the network parameters.
activation_functionstr: The activation function in the embedding net. Supported options are “none”, “gelu_tf”, “linear”, “relu6”, “sigmoid”, “tanh”, “gelu”, “relu”, “softplus”.
precisionstr: The precision of the embedding net parameters. Supported options are “float16”, “float64”, “default”, “float32”.
uniform_seed: Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed
mixed_typesbool: If true, use a uniform fitting net for all atom types, otherwise use different fitting nets for different atom types.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.

ntypes[source]#

dim_descrpt[source]#

n_neuron[source]#

resnet_dt[source]#

sel_type[source]#

sel_mask[source]#

seed[source]#

uniform_seed[source]#

seed_shift[source]#

activation_function_name[source]#

fitting_activation_fn[source]#

fitting_precision[source]#

dim_rot_mat_1[source]#

dim_rot_mat[source]#

useBN = False[source]#

fitting_net_variables = None[source]#

mixed_prec = None[source]#

mixed_types[source]#

type_map[source]#

numb_fparam[source]#

numb_aparam[source]#

fparam_avg = None[source]#

fparam_std = None[source]#

fparam_inv_std = None[source]#

aparam_avg = None[source]#

aparam_std = None[source]#

aparam_inv_std = None[source]#

get_sel_type() → int[source]#: Get selected type.

get_out_size() → int[source]#: Get the output size. Should be 3.

_build_lower(start_index, natoms, inputs, rot_mat, suffix='', reuse=None)[source]#

build(input_d: deepmd.tf.env.tf.Tensor, rot_mat: deepmd.tf.env.tf.Tensor, natoms: deepmd.tf.env.tf.Tensor, input_dict: dict | None = None, reuse: bool | None = None, suffix: str = '') → deepmd.tf.env.tf.Tensor[source]#

Build the computational graph for fitting net.

Parameters:

input_d: The input descriptor
rot_mat: The rotation matrix from the descriptor.
natoms: The number of atoms. This tensor has the length of Ntypes + 2 natoms[0]: number of local atoms natoms[1]: total number of atoms held by this processor natoms[i]: 2 <= i < Ntypes+2, number of type i atoms
input_dict: Additional dict for inputs.
reuse: The weights in the networks should be reused when get the variable.
suffix: Name suffix to identify this descriptor

Returns:

dipole: The atomic dipole.

init_variables(graph: deepmd.tf.env.tf.Graph, graph_def: deepmd.tf.env.tf.GraphDef, suffix: str = '') → None[source]#

Init the fitting net variables with the given dict.

Parameters:

graphtf.Graph: The input frozen model graph
graph_deftf.GraphDef: The input frozen model graph_def
suffixstr: suffix to name scope

enable_mixed_precision(mixed_prec: dict | None = None) → None[source]#

Receive the mixed precision setting.

Parameters:

mixed_prec: The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) → deepmd.tf.loss.loss.Loss[source]#

Get the loss function.

Parameters:

lossdict: the loss dict
lrLearningRateExp: the learning rate

Returns:

Loss: the loss function

serialize(suffix: str) → dict[source]#

Serialize the model.

Returns:

dict: The serialized data

classmethod deserialize(data: dict, suffix: str)[source]#

Deserialize the model.

Parameters:

datadict: The serialized data

Returns:

Model: The deserialized model

property input_requirement: list[deepmd.utils.data.DataRequirementItem][source]#: Return data requirements needed for the model input.

get_numb_fparam() → int[source]#: Get the number of frame parameters.

get_numb_aparam() → int[source]#: Get the number of atomic parameters.