deepmd.fit package
- class deepmd.fit.DOSFitting(*args, **kwargs)[source]
Bases:
FittingFitting 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_name
list[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
precisionPrecision 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 the number of atomic parameters.
Get the number of gridpoints in energy space.
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
enerThe 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
- class deepmd.fit.DipoleFittingSeA(*args, **kwargs)[source]
Bases:
FittingFit the atomic dipole with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[int] The atom types selected to have an atomic dipole prediction. If is None, all atoms are selected.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str 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
- descrpt
- Attributes
precisionPrecision 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 the output size.
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
dipoleThe 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
- class deepmd.fit.EnerFitting(*args, **kwargs)[source]
Bases:
FittingFitting 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_name
list[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
precisionPrecision 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 the number of atomic parameters.
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
enerThe 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
- data
DeepmdDataSystem The training data.
- frozen_model
str The path file of frozen model.
- origin_type_map
list The original type_map in dataset, they are targets to change the energy bias.
- full_type_map
str The full type_map in pretrained model
- bias_shift
str 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.
- ntest
int The number of test samples in a system to change the energy bias.
- data
- 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
- class deepmd.fit.Fitting(*args, **kwargs)[source]
Bases:
PluginVariant- Attributes
precisionPrecision 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
- loss
dict the loss dict
- lr
LearningRateExp the learning rate
- loss
- Returns
Lossthe loss function
- init_variables(graph: Graph, graph_def: GraphDef, suffix: str = '') None[source]
Init the fitting net variables with the given dict.
- Parameters
Notes
This method is called by others when the fitting supported initialization from the given variables.
- property precision: DType
Precision of fitting network.
- 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:
objectFit the system polarizability with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[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.
- scale
List[float] The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]
- diag_shift
List[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.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.
- descrpt
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 the output size.
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
polarThe 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
- class deepmd.fit.PolarFittingSeA(*args, **kwargs)[source]
Bases:
FittingFit the atomic polarizability with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[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.
- scale
List[float] The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]
- diag_shift
List[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.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str 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
- descrpt
- Attributes
precisionPrecision 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 the output size.
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_polarThe 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
Submodules
deepmd.fit.dipole module
- class deepmd.fit.dipole.DipoleFittingSeA(*args, **kwargs)[source]
Bases:
FittingFit the atomic dipole with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[int] The atom types selected to have an atomic dipole prediction. If is None, all atoms are selected.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str 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
- descrpt
- Attributes
precisionPrecision 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 the output size.
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
dipoleThe 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
deepmd.fit.dos module
- class deepmd.fit.dos.DOSFitting(*args, **kwargs)[source]
Bases:
FittingFitting 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_name
list[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
precisionPrecision 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 the number of atomic parameters.
Get the number of gridpoints in energy space.
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
enerThe 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
deepmd.fit.ener module
- class deepmd.fit.ener.EnerFitting(*args, **kwargs)[source]
Bases:
FittingFitting 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_name
list[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
precisionPrecision 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 the number of atomic parameters.
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
enerThe 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
- data
DeepmdDataSystem The training data.
- frozen_model
str The path file of frozen model.
- origin_type_map
list The original type_map in dataset, they are targets to change the energy bias.
- full_type_map
str The full type_map in pretrained model
- bias_shift
str 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.
- ntest
int The number of test samples in a system to change the energy bias.
- data
- 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
deepmd.fit.fitting module
- class deepmd.fit.fitting.Fitting(*args, **kwargs)[source]
Bases:
PluginVariant- Attributes
precisionPrecision 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
- loss
dict the loss dict
- lr
LearningRateExp the learning rate
- loss
- Returns
Lossthe loss function
- init_variables(graph: Graph, graph_def: GraphDef, suffix: str = '') None[source]
Init the fitting net variables with the given dict.
- Parameters
Notes
This method is called by others when the fitting supported initialization from the given variables.
- property precision: DType
Precision of fitting network.
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:
objectFit the system polarizability with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[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.
- scale
List[float] The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]
- diag_shift
List[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.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str The precision of the embedding net parameters. Supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”.
- descrpt
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 the output size.
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
polarThe 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
- class deepmd.fit.polar.PolarFittingSeA(*args, **kwargs)[source]
Bases:
FittingFit the atomic polarizability with descriptor se_a.
- Parameters
- descrpt
tf.Tensor The descrptor
- neuron
List[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_type
List[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.
- scale
List[float] The output of the fitting net (polarizability matrix) for type i atom will be scaled by scale[i]
- diag_shift
List[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.
- seed
int Random seed for initializing the network parameters.
- activation_function
str The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”, “None”, “none”.
- precision
str 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
- descrpt
- Attributes
precisionPrecision 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 the output size.
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_polarThe 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