deepmd.tf.fit.dos

deepmd.tf.fit.dos#

Attributes#

log

Classes#

DOSFitting

Fitting the density of states (DOS) of the system.

Module Contents#

deepmd.tf.fit.dos.log[source]#

class deepmd.tf.fit.dos.DOSFitting(ntypes: int, dim_descrpt: int, neuron: list[int] = [120, 120, 120], resnet_dt: bool = True, numb_fparam: int = 0, numb_aparam: int = 0, dim_case_embd: int = 0, numb_dos: int = 300, rcond: float | None = None, trainable: list[bool] | None = None, seed: int | None = None, activation_function: str = 'tanh', precision: str = 'default', uniform_seed: bool = False, layer_name: list[str | None] | None = None, use_aparam_as_mask: bool = False, mixed_types: bool = False, type_map: list[str] | None = None, default_fparam: list[float] | None = None, **kwargs: Any)[source]#

Bases: deepmd.tf.fit.fitting.Fitting

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

Parameters:

ntypes: The ntypes of the descriptor \(\mathcal{D}\)
dim_descrpt: The dimension of the descriptor \(\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
dim_case_embd: Dimension of case specific embedding.
! 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 “relu6”, “sigmoid”, “none”, “tanh”, “silut”, “gelu”, “linear”, “relu”, “softplus”, “silu”, “gelu_tf”.
precision: The precision of the embedding net parameters. Supported options are “float16”, “default”, “bfloat16”, “float64”, “float32”.
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.
mixed_typesbool: If true, use a uniform fitting net for all atom types, otherwise use different fitting nets for different atom types.
default_fparam: list[float], optional: The default frame parameter. If set, when fparam.npy files are not included in the data system, this value will be used as the default value for the frame parameter in the fitting net.
type_map: list[str], Optional: A list of strings. Give the name to each type of atoms.

ntypes[source]#

dim_descrpt[source]#

use_aparam_as_mask = False[source]#

numb_fparam = 0[source]#

numb_aparam = 0[source]#

dim_case_embd = 0[source]#

default_fparam = None[source]#

numb_dos = 300[source]#

n_neuron = [120, 120, 120][source]#

resnet_dt = True[source]#

rcond = None[source]#

seed = None[source]#

uniform_seed = False[source]#

seed_shift = 3[source]#

activation_function = 'tanh'[source]#

fitting_activation_fn[source]#

fitting_precision[source]#

trainable = None[source]#

useBN = False[source]#

bias_dos[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]#

fitting_net_variables = None[source]#

mixed_prec = None[source]#

layer_name = None[source]#

mixed_types = False[source]#

type_map = None[source]#

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

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

get_numb_dos() → int[source]#: Get the number of gridpoints in energy space.

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

Compute the output 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.

_compute_output_stats(all_stat: dict, rcond: float = 0.001, mixed_type: bool = False) → numpy.ndarray[source]#

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_std(sumv2: numpy.ndarray, sumv: numpy.ndarray, sumn: numpy.ndarray) → numpy.ndarray[source]#

_build_lower(start_index: int, natoms: int, inputs: deepmd.tf.env.tf.Tensor, fparam: deepmd.tf.env.tf.Tensor | None = None, aparam: deepmd.tf.env.tf.Tensor | None = None, bias_dos: float = 0.0, type_suffix: str = '', suffix: str = '', reuse: bool | None = None) → deepmd.tf.env.tf.Tensor[source]#

build(inputs: 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:

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

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.utils.learning_rate.LearningRateExp) → deepmd.tf.loss.loss.Loss[source]#

Get the loss function.

Parameters:

lossdict: the loss dict
lrLearningRateSchedule: the learning rate

Returns:

Loss: the loss function

classmethod deserialize(data: dict, suffix: str = '') → DOSFitting[source]#

Deserialize the model.

Parameters:

datadict: The serialized data

Returns:

Model: The deserialized model

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

Serialize the model.

Returns:

dict: The serialized data

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