deepmd.fit package

class deepmd.fit.DOSFitting(*args, **kwargs)[source]

Bases: Fitting

Fitting the density of states (DOS) of the system. The energy should be shifted by the fermi level.

Parameters
descrpt

The descrptor \(\mathcal{D}\)

neuron

Number of neurons \(N\) in each hidden layer of the fitting net

resnet_dt

Time-step dt in the resnet construction: \(y = x + dt * \phi (Wx + b)\)

numb_fparam

Number of frame parameter

numb_aparam

Number of atomic parameter

! numb_dos (added)

Number of gridpoints on which the DOS is evaluated (NEDOS in VASP)

rcond

The condition number for the regression of atomic energy.

trainable

If the weights of fitting net are trainable. Suppose that we have \(N_l\) hidden layers in the fitting net, this list is of length \(N_l + 1\), specifying if the hidden layers and the output layer are trainable.

seed

Random seed for initializing the network parameters.

activation_function

The activation function \(\boldsymbol{\phi}\) in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precision

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

layer_namelist[Optional[str]], optional

The name of the each layer. If two layers, either in the same fitting or different fittings, have the same name, they will share the same neural network parameters.

use_aparam_as_mask: bool, optional

If True, the atomic parameters will be used as a mask that determines the atom is real/virtual. And the aparam will not be used as the atomic parameters for embedding.

Attributes
precision

Precision of fitting network.

Methods

build(inputs, natoms[, input_dict, reuse, ...])

Build the computational graph for fitting net.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

compute_output_stats(all_stat[, mixed_type])

Compute the ouput statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_numb_aparam()

Get the number of atomic parameters.

get_numb_dos()

Get the number of gridpoints in energy space.

get_numb_fparam()

Get the number of frame parameters.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(inputs: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') Tensor[source]

Build the computational graph for fitting net.

Parameters
inputs

The input descriptor

input_dict

Additional dict for inputs. if numb_fparam > 0, should have input_dict[‘fparam’] if numb_aparam > 0, should have input_dict[‘aparam’]

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

reuse

The weights in the networks should be reused when get the variable.

suffix

Name suffix to identify this descriptor

Returns
ener

The system energy

compute_input_stats(all_stat: dict, protection: float = 0.01) None[source]

Compute the input statistics.

Parameters
all_stat

if numb_fparam > 0 must have all_stat[‘fparam’] if numb_aparam > 0 must have all_stat[‘aparam’] can be prepared by model.make_stat_input

protection

Divided-by-zero protection

compute_output_stats(all_stat: dict, mixed_type: bool = False) None[source]

Compute the ouput statistics.

Parameters
all_stat

must have the following components: all_stat[‘dos’] of shape n_sys x n_batch x n_frame x numb_dos can be prepared by model.make_stat_input

mixed_type

Whether to perform the mixed_type mode. If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), in which frames in a system may have different natoms_vec(s), with the same nloc.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_numb_aparam() int[source]

Get the number of atomic parameters.

get_numb_dos() int[source]

Get the number of gridpoints in energy space.

get_numb_fparam() int[source]

Get the number of frame parameters.

init_variables(graph: Graph, graph_def: 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

class deepmd.fit.DipoleFittingSeA(*args, **kwargs)[source]

Bases: Fitting

Fit the atomic dipole with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

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 “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

Attributes
precision

Precision of fitting network.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected type.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(input_d: Tensor, rot_mat: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') 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.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_out_size() int[source]

Get the output size. Should be 3.

get_sel_type() int[source]

Get selected type.

init_variables(graph: Graph, graph_def: 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

class deepmd.fit.EnerFitting(*args, **kwargs)[source]

Bases: Fitting

Fitting the energy of the system. The force and the virial can also be trained.

The potential energy \(E\) is a fitting network function of the descriptor \(\mathcal{D}\):

\[E(\mathcal{D}) = \mathcal{L}^{(n)} \circ \mathcal{L}^{(n-1)} \circ \cdots \circ \mathcal{L}^{(1)} \circ \mathcal{L}^{(0)}\]

The first \(n\) hidden layers \(\mathcal{L}^{(0)}, \cdots, \mathcal{L}^{(n-1)}\) are given by

\[\mathbf{y}=\mathcal{L}(\mathbf{x};\mathbf{w},\mathbf{b})= \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b})\]

where \(\mathbf{x} \in \mathbb{R}^{N_1}\) is the input vector and \(\mathbf{y} \in \mathbb{R}^{N_2}\) is the output vector. \(\mathbf{w} \in \mathbb{R}^{N_1 \times N_2}\) and \(\mathbf{b} \in \mathbb{R}^{N_2}\) are weights and biases, respectively, both of which are trainable if trainable[i] is True. \(\boldsymbol{\phi}\) is the activation function.

The output layer \(\mathcal{L}^{(n)}\) is given by

\[\mathbf{y}=\mathcal{L}^{(n)}(\mathbf{x};\mathbf{w},\mathbf{b})= \mathbf{x}^T\mathbf{w}+\mathbf{b}\]

where \(\mathbf{x} \in \mathbb{R}^{N_{n-1}}\) is the input vector and \(\mathbf{y} \in \mathbb{R}\) is the output scalar. \(\mathbf{w} \in \mathbb{R}^{N_{n-1}}\) and \(\mathbf{b} \in \mathbb{R}\) are weights and bias, respectively, both of which are trainable if trainable[n] is True.

Parameters
descrpt

The descrptor \(\mathcal{D}\)

neuron

Number of neurons \(N\) in each hidden layer of the fitting net

resnet_dt

Time-step dt in the resnet construction: \(y = x + dt * \phi (Wx + b)\)

numb_fparam

Number of frame parameter

numb_aparam

Number of atomic parameter

rcond

The condition number for the regression of atomic energy.

tot_ener_zero

Force the total energy to zero. Useful for the charge fitting.

trainable

If the weights of fitting net are trainable. Suppose that we have \(N_l\) hidden layers in the fitting net, this list is of length \(N_l + 1\), specifying if the hidden layers and the output layer are trainable.

seed

Random seed for initializing the network parameters.

atom_ener

Specifying atomic energy contribution in vacuum. The set_davg_zero key in the descrptor should be set.

activation_function

The activation function \(\boldsymbol{\phi}\) in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precision

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

layer_namelist[Optional[str]], optional

The name of the each layer. If two layers, either in the same fitting or different fittings, have the same name, they will share the same neural network parameters.

use_aparam_as_mask: bool, optional

If True, the atomic parameters will be used as a mask that determines the atom is real/virtual. And the aparam will not be used as the atomic parameters for embedding.

Attributes
precision

Precision of fitting network.

Methods

build(inputs, natoms[, input_dict, reuse, ...])

Build the computational graph for fitting net.

change_energy_bias(data, frozen_model, ...)

Change the energy bias according to the input data and the pretrained model.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

compute_output_stats(all_stat[, mixed_type])

Compute the ouput statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_numb_aparam()

Get the number of atomic parameters.

get_numb_fparam()

Get the number of frame parameters.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(inputs: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') Tensor[source]

Build the computational graph for fitting net.

Parameters
inputs

The input descriptor

input_dict

Additional dict for inputs. if numb_fparam > 0, should have input_dict[‘fparam’] if numb_aparam > 0, should have input_dict[‘aparam’]

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

reuse

The weights in the networks should be reused when get the variable.

suffix

Name suffix to identify this descriptor

Returns
ener

The system energy

change_energy_bias(data, frozen_model, origin_type_map, full_type_map, bias_shift='delta', ntest=10) None[source]

Change the energy bias according to the input data and the pretrained model.

Parameters
dataDeepmdDataSystem

The training data.

frozen_modelstr

The path file of frozen model.

origin_type_maplist

The original type_map in dataset, they are targets to change the energy bias.

full_type_mapstr

The full type_map in pretrained model

bias_shiftstr

The mode for changing energy bias : [‘delta’, ‘statistic’] ‘delta’ : perform predictions on energies of target dataset,

and do least sqaure on the errors to obtain the target shift as bias.

‘statistic’ : directly use the statistic energy bias in the target dataset.

ntestint

The number of test samples in a system to change the energy bias.

compute_input_stats(all_stat: dict, protection: float = 0.01) None[source]

Compute the input statistics.

Parameters
all_stat

if numb_fparam > 0 must have all_stat[‘fparam’] if numb_aparam > 0 must have all_stat[‘aparam’] can be prepared by model.make_stat_input

protection

Divided-by-zero protection

compute_output_stats(all_stat: dict, mixed_type: bool = False) None[source]

Compute the ouput statistics.

Parameters
all_stat

must have the following components: all_stat[‘energy’] of shape n_sys x n_batch x n_frame can be prepared by model.make_stat_input

mixed_type

Whether to perform the mixed_type mode. If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), in which frames in a system may have different natoms_vec(s), with the same nloc.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

The loss function parameters.

lrLearningRateExp

The learning rate.

Returns
Loss

The loss function.

get_numb_aparam() int[source]

Get the number of atomic parameters.

get_numb_fparam() int[source]

Get the number of frame parameters.

init_variables(graph: Graph, graph_def: 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

class deepmd.fit.Fitting(*args, **kwargs)[source]

Bases: PluginVariant

Attributes
precision

Precision of fitting network.

Methods

get_loss(loss, lr)

Get the loss function.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

abstract get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

init_variables(graph: Graph, graph_def: 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

Notes

This method is called by others when the fitting supported initialization from the given variables.

property precision: DType

Precision of fitting network.

static register(key: str) Callable[source]

Register a Fitting plugin.

Parameters
keystr

the key of a Fitting

Returns
Fitting

the registered Fitting

Examples

>>> @Fitting.register("some_fitting")
    class SomeFitting(Fitting):
        pass
class deepmd.fit.GlobalPolarFittingSeA(descrpt: Tensor, neuron: List[int] = [120, 120, 120], resnet_dt: bool = True, sel_type: Optional[List[int]] = None, fit_diag: bool = True, scale: Optional[List[float]] = None, diag_shift: Optional[List[float]] = None, seed: Optional[int] = None, activation_function: str = 'tanh', precision: str = 'default')[source]

Bases: object

Fit the system polarizability with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

sel_typeList[int]

The atom types selected to have an atomic polarizability prediction

fit_diagbool

Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix.

scaleList[float]

The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]

diag_shiftList[float]

The diagonal part of the polarizability matrix of type i will be shifted by diag_shift[i]. The shift operation is carried out after scale.

seedint

Random seed for initializing the network parameters.

activation_functionstr

The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected atom types.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

build(input_d, rot_mat, natoms, input_dict: Optional[dict] = None, reuse=None, suffix='') 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
polar

The system polarizability

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_out_size() int[source]

Get the output size. Should be 9.

get_sel_type() int[source]

Get selected atom types.

init_variables(graph: Graph, graph_def: 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

class deepmd.fit.PolarFittingSeA(*args, **kwargs)[source]

Bases: Fitting

Fit the atomic polarizability with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

sel_typeList[int]

The atom types selected to have an atomic polarizability prediction. If is None, all atoms are selected.

fit_diagbool

Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix.

scaleList[float]

The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]

diag_shiftList[float]

The diagonal part of the polarizability matrix of type i will be shifted by diag_shift[i]. The shift operation is carried out after scale.

seedint

Random seed for initializing the network parameters.

activation_functionstr

The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

Attributes
precision

Precision of fitting network.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected atom types.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(input_d: Tensor, rot_mat: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '')[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
atomic_polar

The atomic polarizability

compute_input_stats(all_stat, protection=0.01)[source]

Compute the input statistics.

Parameters
all_stat

Dictionary of inputs. can be prepared by model.make_stat_input

protection

Divided-by-zero protection

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

get_out_size() int[source]

Get the output size. Should be 9.

get_sel_type() List[int][source]

Get selected atom types.

init_variables(graph: Graph, graph_def: 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

Submodules

deepmd.fit.dipole module

class deepmd.fit.dipole.DipoleFittingSeA(*args, **kwargs)[source]

Bases: Fitting

Fit the atomic dipole with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

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 “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

Attributes
precision

Precision of fitting network.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected type.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(input_d: Tensor, rot_mat: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') 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.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_out_size() int[source]

Get the output size. Should be 3.

get_sel_type() int[source]

Get selected type.

init_variables(graph: Graph, graph_def: 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

deepmd.fit.dos module

class deepmd.fit.dos.DOSFitting(*args, **kwargs)[source]

Bases: Fitting

Fitting the density of states (DOS) of the system. The energy should be shifted by the fermi level.

Parameters
descrpt

The descrptor \(\mathcal{D}\)

neuron

Number of neurons \(N\) in each hidden layer of the fitting net

resnet_dt

Time-step dt in the resnet construction: \(y = x + dt * \phi (Wx + b)\)

numb_fparam

Number of frame parameter

numb_aparam

Number of atomic parameter

! numb_dos (added)

Number of gridpoints on which the DOS is evaluated (NEDOS in VASP)

rcond

The condition number for the regression of atomic energy.

trainable

If the weights of fitting net are trainable. Suppose that we have \(N_l\) hidden layers in the fitting net, this list is of length \(N_l + 1\), specifying if the hidden layers and the output layer are trainable.

seed

Random seed for initializing the network parameters.

activation_function

The activation function \(\boldsymbol{\phi}\) in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precision

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

layer_namelist[Optional[str]], optional

The name of the each layer. If two layers, either in the same fitting or different fittings, have the same name, they will share the same neural network parameters.

use_aparam_as_mask: bool, optional

If True, the atomic parameters will be used as a mask that determines the atom is real/virtual. And the aparam will not be used as the atomic parameters for embedding.

Attributes
precision

Precision of fitting network.

Methods

build(inputs, natoms[, input_dict, reuse, ...])

Build the computational graph for fitting net.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

compute_output_stats(all_stat[, mixed_type])

Compute the ouput statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_numb_aparam()

Get the number of atomic parameters.

get_numb_dos()

Get the number of gridpoints in energy space.

get_numb_fparam()

Get the number of frame parameters.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(inputs: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') Tensor[source]

Build the computational graph for fitting net.

Parameters
inputs

The input descriptor

input_dict

Additional dict for inputs. if numb_fparam > 0, should have input_dict[‘fparam’] if numb_aparam > 0, should have input_dict[‘aparam’]

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

reuse

The weights in the networks should be reused when get the variable.

suffix

Name suffix to identify this descriptor

Returns
ener

The system energy

compute_input_stats(all_stat: dict, protection: float = 0.01) None[source]

Compute the input statistics.

Parameters
all_stat

if numb_fparam > 0 must have all_stat[‘fparam’] if numb_aparam > 0 must have all_stat[‘aparam’] can be prepared by model.make_stat_input

protection

Divided-by-zero protection

compute_output_stats(all_stat: dict, mixed_type: bool = False) None[source]

Compute the ouput statistics.

Parameters
all_stat

must have the following components: all_stat[‘dos’] of shape n_sys x n_batch x n_frame x numb_dos can be prepared by model.make_stat_input

mixed_type

Whether to perform the mixed_type mode. If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), in which frames in a system may have different natoms_vec(s), with the same nloc.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_numb_aparam() int[source]

Get the number of atomic parameters.

get_numb_dos() int[source]

Get the number of gridpoints in energy space.

get_numb_fparam() int[source]

Get the number of frame parameters.

init_variables(graph: Graph, graph_def: 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

deepmd.fit.ener module

class deepmd.fit.ener.EnerFitting(*args, **kwargs)[source]

Bases: Fitting

Fitting the energy of the system. The force and the virial can also be trained.

The potential energy \(E\) is a fitting network function of the descriptor \(\mathcal{D}\):

\[E(\mathcal{D}) = \mathcal{L}^{(n)} \circ \mathcal{L}^{(n-1)} \circ \cdots \circ \mathcal{L}^{(1)} \circ \mathcal{L}^{(0)}\]

The first \(n\) hidden layers \(\mathcal{L}^{(0)}, \cdots, \mathcal{L}^{(n-1)}\) are given by

\[\mathbf{y}=\mathcal{L}(\mathbf{x};\mathbf{w},\mathbf{b})= \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b})\]

where \(\mathbf{x} \in \mathbb{R}^{N_1}\) is the input vector and \(\mathbf{y} \in \mathbb{R}^{N_2}\) is the output vector. \(\mathbf{w} \in \mathbb{R}^{N_1 \times N_2}\) and \(\mathbf{b} \in \mathbb{R}^{N_2}\) are weights and biases, respectively, both of which are trainable if trainable[i] is True. \(\boldsymbol{\phi}\) is the activation function.

The output layer \(\mathcal{L}^{(n)}\) is given by

\[\mathbf{y}=\mathcal{L}^{(n)}(\mathbf{x};\mathbf{w},\mathbf{b})= \mathbf{x}^T\mathbf{w}+\mathbf{b}\]

where \(\mathbf{x} \in \mathbb{R}^{N_{n-1}}\) is the input vector and \(\mathbf{y} \in \mathbb{R}\) is the output scalar. \(\mathbf{w} \in \mathbb{R}^{N_{n-1}}\) and \(\mathbf{b} \in \mathbb{R}\) are weights and bias, respectively, both of which are trainable if trainable[n] is True.

Parameters
descrpt

The descrptor \(\mathcal{D}\)

neuron

Number of neurons \(N\) in each hidden layer of the fitting net

resnet_dt

Time-step dt in the resnet construction: \(y = x + dt * \phi (Wx + b)\)

numb_fparam

Number of frame parameter

numb_aparam

Number of atomic parameter

rcond

The condition number for the regression of atomic energy.

tot_ener_zero

Force the total energy to zero. Useful for the charge fitting.

trainable

If the weights of fitting net are trainable. Suppose that we have \(N_l\) hidden layers in the fitting net, this list is of length \(N_l + 1\), specifying if the hidden layers and the output layer are trainable.

seed

Random seed for initializing the network parameters.

atom_ener

Specifying atomic energy contribution in vacuum. The set_davg_zero key in the descrptor should be set.

activation_function

The activation function \(\boldsymbol{\phi}\) in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precision

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

layer_namelist[Optional[str]], optional

The name of the each layer. If two layers, either in the same fitting or different fittings, have the same name, they will share the same neural network parameters.

use_aparam_as_mask: bool, optional

If True, the atomic parameters will be used as a mask that determines the atom is real/virtual. And the aparam will not be used as the atomic parameters for embedding.

Attributes
precision

Precision of fitting network.

Methods

build(inputs, natoms[, input_dict, reuse, ...])

Build the computational graph for fitting net.

change_energy_bias(data, frozen_model, ...)

Change the energy bias according to the input data and the pretrained model.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

compute_output_stats(all_stat[, mixed_type])

Compute the ouput statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_numb_aparam()

Get the number of atomic parameters.

get_numb_fparam()

Get the number of frame parameters.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(inputs: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') Tensor[source]

Build the computational graph for fitting net.

Parameters
inputs

The input descriptor

input_dict

Additional dict for inputs. if numb_fparam > 0, should have input_dict[‘fparam’] if numb_aparam > 0, should have input_dict[‘aparam’]

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

reuse

The weights in the networks should be reused when get the variable.

suffix

Name suffix to identify this descriptor

Returns
ener

The system energy

change_energy_bias(data, frozen_model, origin_type_map, full_type_map, bias_shift='delta', ntest=10) None[source]

Change the energy bias according to the input data and the pretrained model.

Parameters
dataDeepmdDataSystem

The training data.

frozen_modelstr

The path file of frozen model.

origin_type_maplist

The original type_map in dataset, they are targets to change the energy bias.

full_type_mapstr

The full type_map in pretrained model

bias_shiftstr

The mode for changing energy bias : [‘delta’, ‘statistic’] ‘delta’ : perform predictions on energies of target dataset,

and do least sqaure on the errors to obtain the target shift as bias.

‘statistic’ : directly use the statistic energy bias in the target dataset.

ntestint

The number of test samples in a system to change the energy bias.

compute_input_stats(all_stat: dict, protection: float = 0.01) None[source]

Compute the input statistics.

Parameters
all_stat

if numb_fparam > 0 must have all_stat[‘fparam’] if numb_aparam > 0 must have all_stat[‘aparam’] can be prepared by model.make_stat_input

protection

Divided-by-zero protection

compute_output_stats(all_stat: dict, mixed_type: bool = False) None[source]

Compute the ouput statistics.

Parameters
all_stat

must have the following components: all_stat[‘energy’] of shape n_sys x n_batch x n_frame can be prepared by model.make_stat_input

mixed_type

Whether to perform the mixed_type mode. If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), in which frames in a system may have different natoms_vec(s), with the same nloc.

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

The loss function parameters.

lrLearningRateExp

The learning rate.

Returns
Loss

The loss function.

get_numb_aparam() int[source]

Get the number of atomic parameters.

get_numb_fparam() int[source]

Get the number of frame parameters.

init_variables(graph: Graph, graph_def: 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

deepmd.fit.fitting module

class deepmd.fit.fitting.Fitting(*args, **kwargs)[source]

Bases: PluginVariant

Attributes
precision

Precision of fitting network.

Methods

get_loss(loss, lr)

Get the loss function.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

abstract get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

init_variables(graph: Graph, graph_def: 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

Notes

This method is called by others when the fitting supported initialization from the given variables.

property precision: DType

Precision of fitting network.

static register(key: str) Callable[source]

Register a Fitting plugin.

Parameters
keystr

the key of a Fitting

Returns
Fitting

the registered Fitting

Examples

>>> @Fitting.register("some_fitting")
    class SomeFitting(Fitting):
        pass

deepmd.fit.polar module

class deepmd.fit.polar.GlobalPolarFittingSeA(descrpt: Tensor, neuron: List[int] = [120, 120, 120], resnet_dt: bool = True, sel_type: Optional[List[int]] = None, fit_diag: bool = True, scale: Optional[List[float]] = None, diag_shift: Optional[List[float]] = None, seed: Optional[int] = None, activation_function: str = 'tanh', precision: str = 'default')[source]

Bases: object

Fit the system polarizability with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

sel_typeList[int]

The atom types selected to have an atomic polarizability prediction

fit_diagbool

Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix.

scaleList[float]

The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]

diag_shiftList[float]

The diagonal part of the polarizability matrix of type i will be shifted by diag_shift[i]. The shift operation is carried out after scale.

seedint

Random seed for initializing the network parameters.

activation_functionstr

The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected atom types.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

build(input_d, rot_mat, natoms, input_dict: Optional[dict] = None, reuse=None, suffix='') 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
polar

The system polarizability

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

Parameters
lossdict

the loss dict

lrLearningRateExp

the learning rate

Returns
Loss

the loss function

get_out_size() int[source]

Get the output size. Should be 9.

get_sel_type() int[source]

Get selected atom types.

init_variables(graph: Graph, graph_def: 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

class deepmd.fit.polar.PolarFittingSeA(*args, **kwargs)[source]

Bases: Fitting

Fit the atomic polarizability with descriptor se_a.

Parameters
descrpttf.Tensor

The descrptor

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)

sel_typeList[int]

The atom types selected to have an atomic polarizability prediction. If is None, all atoms are selected.

fit_diagbool

Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix.

scaleList[float]

The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]

diag_shiftList[float]

The diagonal part of the polarizability matrix of type i will be shifted by diag_shift[i]. The shift operation is carried out after scale.

seedint

Random seed for initializing the network parameters.

activation_functionstr

The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.

precisionstr

The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.

uniform_seed

Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed

Attributes
precision

Precision of fitting network.

Methods

build(input_d, rot_mat, natoms[, ...])

Build the computational graph for fitting net.

compute_input_stats(all_stat[, protection])

Compute the input statistics.

enable_mixed_precision([mixed_prec])

Reveive the mixed precision setting.

get_loss(loss, lr)

Get the loss function.

get_out_size()

Get the output size.

get_sel_type()

Get selected atom types.

init_variables(graph, graph_def[, suffix])

Init the fitting net variables with the given dict.

register(key)

Register a Fitting plugin.

build(input_d: Tensor, rot_mat: Tensor, natoms: Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '')[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
atomic_polar

The atomic polarizability

compute_input_stats(all_stat, protection=0.01)[source]

Compute the input statistics.

Parameters
all_stat

Dictionary of inputs. can be prepared by model.make_stat_input

protection

Divided-by-zero protection

enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]

Reveive the mixed precision setting.

Parameters
mixed_prec

The mixed precision setting used in the embedding net

get_loss(loss: dict, lr) Loss[source]

Get the loss function.

get_out_size() int[source]

Get the output size. Should be 9.

get_sel_type() List[int][source]

Get selected atom types.

init_variables(graph: Graph, graph_def: 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