# deepmd.utils package

class deepmd.utils.DeepmdData(sys_path: str, set_prefix: str = 'set', shuffle_test: bool = True, type_map: List[str] | None = None, optional_type_map: bool = True, modifier=None, trn_all_set: bool = False)[source]

Bases: object

Class for a data system.

It loads data from hard disk, and mantains the data as a data_dict

Parameters:
sys_path

Path to the data system

set_prefix

Prefix for the directories of different sets

shuffle_test

If the test data are shuffled

type_map

Gives the name of different atom types

optional_type_map

If the type_map.raw in each system is optional

modifier

Data modifier that has the method modify_data

trn_all_set

Use all sets as training dataset. Otherwise, if the number of sets is more than 1, the last set is left for test.

Methods

 add(key, ndof[, atomic, must, high_prec, ...]) Add a data item that to be loaded. avg(key) Return the average value of an item. check_batch_size(batch_size) Check if the system can get a batch of data with batch_size frames. check_test_size(test_size) Check if the system can get a test dataset with test_size frames. Get atom types. get_batch(batch_size) Get a batch of data with batch_size frames. Get the data_dict. Get number of atoms. get_natoms_vec(ntypes) Get number of atoms and number of atoms in different types. Number of atom types in the system. get_numb_batch(batch_size, set_idx) Get the number of batches in a set. Get number of training sets. get_sys_numb_batch(batch_size) Get the number of batches in the data system. get_test([ntests]) Get the test data with ntests frames. Get the type map. reduce(key_out, key_in) Generate a new item from the reduction of another atom.
 reset_get_batch
add(key: str, ndof: int, atomic: bool = False, must: bool = False, high_prec: bool = False, type_sel: List[int] | None = None, repeat: int = 1, default: float = 0.0, dtype: = None)[source]

Parameters:
key

The key of the item. The corresponding data is stored in sys_path/set.*/key.npy

ndof

The number of dof

atomic

The item is an atomic property. If False, the size of the data should be nframes x ndof If True, the size of data should be nframes x natoms x ndof

must

The data file sys_path/set.*/key.npy must exist. If must is False and the data file does not exist, the data_dict[find_key] is set to 0.0

high_prec

Load the data and store in float64, otherwise in float32

type_sel

Select certain type of atoms

repeat

The data will be repeated repeat times.

defaultfloat, default=0.

default value of data

dtypenp.dtype, optional

the dtype of data, overwrites high_prec if provided

avg(key)[source]

Return the average value of an item.

check_batch_size(batch_size)[source]

Check if the system can get a batch of data with batch_size frames.

check_test_size(test_size)[source]

Check if the system can get a test dataset with test_size frames.

get_atom_type() List[int][source]

Get atom types.

get_batch(batch_size: int) dict[source]

Get a batch of data with batch_size frames. The frames are randomly picked from the data system.

Parameters:
batch_size

size of the batch

get_data_dict() dict[source]

Get the data_dict.

get_natoms()[source]

Get number of atoms.

get_natoms_vec(ntypes: int)[source]

Get number of atoms and number of atoms in different types.

Parameters:
ntypes

Number of types (may be larger than the actual number of types in the system).

Returns:
natoms

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

get_ntypes() int[source]

Number of atom types in the system.

get_numb_batch(batch_size: int, set_idx: int) int[source]

Get the number of batches in a set.

get_numb_set() int[source]

Get number of training sets.

get_sys_numb_batch(batch_size: int) int[source]

Get the number of batches in the data system.

get_test(ntests: int = -1) dict[source]

Get the test data with ntests frames.

Parameters:
ntests

Size of the test data set. If ntests is -1, all test data will be get.

get_type_map() List[str][source]

Get the type map.

reduce(key_out: str, key_in: str)[source]

Generate a new item from the reduction of another atom.

Parameters:
key_out

The name of the reduced item

key_in

The name of the data item to be reduced

reset_get_batch()[source]
class deepmd.utils.DeepmdDataSystem(systems: List[str], batch_size: int, test_size: int, rcut: float, set_prefix: str = 'set', shuffle_test: bool = True, type_map: List[str] | None = None, optional_type_map: bool = True, modifier=None, trn_all_set=False, sys_probs=None, auto_prob_style='prob_sys_size')[source]

Bases: object

Class for manipulating many data systems.

It is implemented with the help of DeepmdData

Methods

 add(key, ndof[, atomic, must, high_prec, ...]) Add a data item that to be loaded. add_dict(adict) Add items to the data system by a dict. get_batch([sys_idx]) Get a batch of data from the data systems. Get a batch of data from the data systems in the mixed way. Get the batch size. get_batch_standard([sys_idx]) Get a batch of data from the data systems in the standard way. Get the total number of batches. Get the number of data systems. Get the number of types. get_sys(idx) Get a certain data system. get_sys_ntest([sys_idx]) Get number of tests for the currently selected system, or one defined by sys_idx. get_test([sys_idx, n_test]) Get test data from the the data systems. Get the type map. reduce(key_out, key_in) Generate a new item from the reduction of another atom.
 compute_energy_shift get_data_dict print_summary set_sys_probs
add(key: str, ndof: int, atomic: bool = False, must: bool = False, high_prec: bool = False, type_sel: List[int] | None = None, repeat: int = 1, default: float = 0.0)[source]

Parameters:
key

The key of the item. The corresponding data is stored in sys_path/set.*/key.npy

ndof

The number of dof

atomic

The item is an atomic property. If False, the size of the data should be nframes x ndof If True, the size of data should be nframes x natoms x ndof

must

The data file sys_path/set.*/key.npy must exist. If must is False and the data file does not exist, the data_dict[find_key] is set to 0.0

high_prec

Load the data and store in float64, otherwise in float32

type_sel

Select certain type of atoms

repeat

The data will be repeated repeat times.

default, default=0.

Default value of data

Add items to the data system by a dict. adict should have items like .. code-block:: python.

“ndof”: ndof, “atomic”: atomic, “must”: must, “high_prec”: high_prec, “type_sel”: type_sel, “repeat”: repeat,

}

For the explaination of the keys see add

compute_energy_shift(rcond=0.001, key='energy')[source]
get_batch(sys_idx: = None) dict[source]

Get a batch of data from the data systems.

Parameters:
sys_idxint

The index of system from which the batch is get. If sys_idx is not None, sys_probs and auto_prob_style are ignored If sys_idx is None, automatically determine the system according to sys_probs or auto_prob_style, see the following. This option does not work for mixed systems.

Returns:
dict

The batch data

get_batch_mixed() dict[source]

Get a batch of data from the data systems in the mixed way.

Returns:
dict

The batch data

get_batch_size() int[source]

Get the batch size.

get_batch_standard(sys_idx: = None) dict[source]

Get a batch of data from the data systems in the standard way.

Parameters:
sys_idxint

The index of system from which the batch is get. If sys_idx is not None, sys_probs and auto_prob_style are ignored If sys_idx is None, automatically determine the system according to sys_probs or auto_prob_style, see the following.

Returns:
dict

The batch data

get_data_dict(ii: int = 0) dict[source]
get_nbatches() int[source]

Get the total number of batches.

get_nsystems() int[source]

Get the number of data systems.

get_ntypes() int[source]

Get the number of types.

get_sys(idx: int) [source]

Get a certain data system.

get_sys_ntest(sys_idx=None)[source]

Get number of tests for the currently selected system, or one defined by sys_idx.

get_test(sys_idx: = None, n_test: int = -1)[source]

Get test data from the the data systems.

Parameters:
sys_idx

The test dat of system with index sys_idx will be returned. If is None, the currently selected system will be returned.

n_test

Number of test data. If set to -1 all test data will be get.

get_type_map() List[str][source]

Get the type map.

print_summary(name)[source]
reduce(key_out, key_in)[source]

Generate a new item from the reduction of another atom.

Parameters:
key_out

The name of the reduced item

key_in

The name of the data item to be reduced

set_sys_probs(sys_probs=None, auto_prob_style: str = 'prob_sys_size')[source]
class deepmd.utils.LearningRateExp(start_lr: float, stop_lr: float = 5e-08, decay_steps: int = 5000, decay_rate: float = 0.95)[source]

Bases: object

The exponentially decaying learning rate.

The learning rate at step $$t$$ is given by

$\alpha(t) = \alpha_0 \lambda ^ { t / \tau }$

where $$\alpha$$ is the learning rate, $$\alpha_0$$ is the starting learning rate, $$\lambda$$ is the decay rate, and $$\tau$$ is the decay steps.

Parameters:
start_lr

Starting learning rate $$\alpha_0$$

stop_lr

Stop learning rate $$\alpha_1$$

decay_steps

Learning rate decay every this number of steps $$\tau$$

decay_rate

The decay rate $$\lambda$$. If stop_step is provided in build, then it will be determined automatically and overwritten.

Methods

 build(global_step[, stop_step]) Build the learning rate. Get the start lr. value(step) Get the lr at a certain step.
build(global_step: Tensor, stop_step: = None) Tensor[source]

Build the learning rate.

Parameters:
global_step

The tf Tensor prividing the global training step

stop_step

The stop step. If provided, the decay_rate will be determined automatically and overwritten.

Returns:
learning_rate

The learning rate

start_lr() [source]

Get the start lr.

value(step: int) [source]

Get the lr at a certain step.

class deepmd.utils.PairTab(filename: str)[source]

Bases: object

Parameters:
filename

File name for the short-range tabulated potential. The table is a text data file with (N_t + 1) * N_t / 2 + 1 columes. The first colume is the distance between atoms. The second to the last columes are energies for pairs of certain types. For example we have two atom types, 0 and 1. The columes from 2nd to 4th are for 0-0, 0-1 and 1-1 correspondingly.

Methods

 Get the serialized table. reinit(filename) Initialize the tabulated interaction.
get() Tuple[array, array][source]

Get the serialized table.

reinit(filename: str) None[source]

Initialize the tabulated interaction.

Parameters:
filename

File name for the short-range tabulated potential. The table is a text data file with (N_t + 1) * N_t / 2 + 1 columes. The first colume is the distance between atoms. The second to the last columes are energies for pairs of certain types. For example we have two atom types, 0 and 1. The columes from 2nd to 4th are for 0-0, 0-1 and 1-1 correspondingly.

class deepmd.utils.Plugin[source]

Bases: object

A class to register and restore plugins.

Examples

>>> plugin = Plugin()
>>> @plugin.register("xx")
def xxx():
pass
>>> print(plugin.plugins['xx'])

Attributes:
plugins

plugins

Methods

 get_plugin(key) Visit a plugin by key. register(key) Register a plugin.
get_plugin(key) [source]

Visit a plugin by key.

Parameters:
keystr

key of the plugin

Returns:
object

the plugin

register(key: str) Callable[[object], object][source]

Register a plugin.

Parameters:
keystr

key of the plugin

Returns:
Callable[[object], object]

decorator

class deepmd.utils.PluginVariant(*args, **kwargs)[source]

Bases: object

A class to remove type from input arguments.

## deepmd.utils.argcheck module

class deepmd.utils.argcheck.ArgsPlugin[source]

Bases: object

Methods

 get_all_argument([exclude_hybrid]) Get all arguments. register(name[, alias]) Regiester a descriptor argument plugin.
get_all_argument(exclude_hybrid: bool = False) List[Argument][source]

Get all arguments.

Parameters:
exclude_hybridbool

exclude hybrid descriptor to prevent circular calls

Returns:
List[Argument]

all arguments

register(name: str, alias: List[str] | None = None) Callable[[], List[Argument]][source]

Regiester a descriptor argument plugin.

Parameters:
namestr

the name of a descriptor

aliasList[str], optional

the list of aliases of this descriptor

Returns:
Callable[[], List[Argument]]

the regiestered descriptor argument method

Examples

>>> some_plugin = ArgsPlugin()
>>> @some_plugin.register("some_descrpt")
def descrpt_some_descrpt_args():
return []

deepmd.utils.argcheck.descrpt_hybrid_args()[source]
deepmd.utils.argcheck.descrpt_local_frame_args()[source]
deepmd.utils.argcheck.descrpt_se_a_args()[source]
deepmd.utils.argcheck.descrpt_se_a_tpe_args()[source]
deepmd.utils.argcheck.descrpt_se_atten_args()[source]
deepmd.utils.argcheck.descrpt_se_r_args()[source]
deepmd.utils.argcheck.descrpt_se_t_args()[source]
deepmd.utils.argcheck.descrpt_variant_type_args(exclude_hybrid: bool = False) Variant[source]
deepmd.utils.argcheck.fitting_dipole()[source]
deepmd.utils.argcheck.fitting_ener()[source]
deepmd.utils.argcheck.fitting_polar()[source]
deepmd.utils.argcheck.fitting_variant_type_args()[source]
deepmd.utils.argcheck.gen_args(**kwargs)[source]
deepmd.utils.argcheck.gen_json(**kwargs)[source]
deepmd.utils.argcheck.learning_rate_args()[source]
deepmd.utils.argcheck.learning_rate_exp()[source]
deepmd.utils.argcheck.learning_rate_variant_type_args()[source]
deepmd.utils.argcheck.limit_pref(item)[source]
deepmd.utils.argcheck.list_to_doc(xx)[source]
deepmd.utils.argcheck.loss_args()[source]
deepmd.utils.argcheck.loss_dict_args()[source]
deepmd.utils.argcheck.loss_ener()[source]
deepmd.utils.argcheck.loss_tensor()[source]
deepmd.utils.argcheck.loss_variant_type_args()[source]
deepmd.utils.argcheck.make_index(keys)[source]
deepmd.utils.argcheck.mixed_precision_args()[source]
deepmd.utils.argcheck.model_args()[source]
deepmd.utils.argcheck.model_compression()[source]
deepmd.utils.argcheck.model_compression_type_args()[source]
deepmd.utils.argcheck.modifier_dipole_charge()[source]
deepmd.utils.argcheck.modifier_variant_type_args()[source]
deepmd.utils.argcheck.normalize(data)[source]
deepmd.utils.argcheck.normalize_data_dict(data_dict)[source]
deepmd.utils.argcheck.normalize_fitting_net_dict(fitting_net_dict)[source]
deepmd.utils.argcheck.normalize_fitting_weight(fitting_keys, data_keys, fitting_weight=None)[source]
deepmd.utils.argcheck.normalize_hybrid_list(hy_list)[source]
deepmd.utils.argcheck.normalize_loss_dict(fitting_keys, loss_dict)[source]
deepmd.utils.argcheck.start_pref(item)[source]
deepmd.utils.argcheck.training_args()[source]
deepmd.utils.argcheck.training_data_args()[source]
deepmd.utils.argcheck.type_embedding_args()[source]
deepmd.utils.argcheck.validation_data_args()[source]

## deepmd.utils.batch_size module

class deepmd.utils.batch_size.AutoBatchSize(initial_batch_size: int = 1024, factor: float = 2.0)[source]

Bases: object

This class allows DeePMD-kit to automatically decide the maximum batch size that will not cause an OOM error.

Parameters:
initial_batch_sizeint, default: 1024

initial batch size (number of total atoms) when DP_INFER_BATCH_SIZE is not set

factorfloat, default: 2.

increased factor

Notes

In some CPU environments, the program may be directly killed when OOM. In this case, by default the batch size will not be increased for CPUs. The environment variable DP_INFER_BATCH_SIZE can be set as the batch size.

In other cases, we assume all OOM error will raise OutOfMemoryError.

Attributes:
current_batch_sizeint

current batch size (number of total atoms)

maximum_working_batch_sizeint

maximum working batch size

minimal_not_working_batch_sizeint

minimal not working batch size

Methods

 execute(callable, start_index, natoms) Excuate a method with given batch size. execute_all(callable, total_size, natoms, ...) Excuate a method with all given data.
execute(callable: Callable, start_index: int, natoms: int) [source]

Excuate a method with given batch size.

Parameters:
callableCallable

The method should accept the batch size and start_index as parameters, and returns executed batch size and data.

start_indexint

start index

natomsint

natoms

Returns:
int

executed batch size * number of atoms

tuple

result from callable, None if failing to execute

Raises:
OutOfMemoryError

OOM when batch size is 1

execute_all(callable: Callable, total_size: int, natoms: int, *args, **kwargs) [source]

Excuate a method with all given data.

Parameters:
callableCallable

The method should accept *args and **kwargs as input and return the similiar array.

total_sizeint

Total size

natomsint

The number of atoms

*args

Variable length argument list.

**kwargs

If 2D np.ndarray, assume the first axis is batch; otherwise do nothing.

## deepmd.utils.compat module

Module providing compatibility between 0.x.x and 1.x.x input versions.

deepmd.utils.compat.convert_input_v0_v1(jdata: Dict[str, Any], warning: bool = True, dump: = None) Dict[str, Any][source]

Convert input from v0 format to v1.

Parameters:
jdata

warningbool, optional

whether to show deprecation warning, by default True

dumpOptional[Union[str, Path]], optional

whether to dump converted file, by default None

Returns:
Dict[str, Any]

converted output

deepmd.utils.compat.convert_input_v1_v2(jdata: Dict[str, Any], warning: bool = True, dump: = None) Dict[str, Any][source]
deepmd.utils.compat.deprecate_numb_test(jdata: Dict[str, Any], warning: bool = True, dump: = None) Dict[str, Any][source]

Deprecate numb_test since v2.1. It has taken no effect since v2.0.

See #1243.

Parameters:
jdata

warningbool, optional

whether to show deprecation warning, by default True

dumpOptional[Union[str, Path]], optional

whether to dump converted file, by default None

Returns:
Dict[str, Any]

converted output

deepmd.utils.compat.remove_decay_rate(jdata: Dict[str, Any])[source]

Convert decay_rate to stop_lr.

Parameters:
jdata

input data

deepmd.utils.compat.update_deepmd_input(jdata: Dict[str, Any], warning: bool = True, dump: = None) Dict[str, Any][source]

## deepmd.utils.convert module

deepmd.utils.convert.convert_012_to_21(input_model: str, output_model: str)[source]

Convert DP 0.12 graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.convert_10_to_21(input_model: str, output_model: str)[source]

Convert DP 1.0 graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.convert_12_to_21(input_model: str, output_model: str)[source]

Convert DP 1.2 graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.convert_13_to_21(input_model: str, output_model: str)[source]

Convert DP 1.3 graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.convert_20_to_21(input_model: str, output_model: str)[source]

Convert DP 2.0 graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.convert_dp012_to_dp10(file: str)[source]

Convert DP 0.12 graph text to 1.0 graph text.

Parameters:
filestr

filename of the graph text

deepmd.utils.convert.convert_dp10_to_dp11(file: str)[source]

Convert DP 1.0 graph text to 1.1 graph text.

Parameters:
filestr

filename of the graph text

deepmd.utils.convert.convert_dp12_to_dp13(file: str)[source]

Convert DP 1.2 graph text to 1.3 graph text.

Parameters:
filestr

filename of the graph text

deepmd.utils.convert.convert_dp13_to_dp20(fname: str)[source]

Convert DP 1.3 graph text to 2.0 graph text.

Parameters:
fnamestr

filename of the graph text

deepmd.utils.convert.convert_dp20_to_dp21(fname: str)[source]
deepmd.utils.convert.convert_pb_to_pbtxt(pbfile: str, pbtxtfile: str)[source]

Convert DP graph to graph text.

Parameters:
pbfilestr

filename of the input graph

pbtxtfilestr

filename of the output graph text

deepmd.utils.convert.convert_pbtxt_to_pb(pbtxtfile: str, pbfile: str)[source]

Convert DP graph text to graph.

Parameters:
pbtxtfilestr

filename of the input graph text

pbfilestr

filename of the output graph

deepmd.utils.convert.convert_to_21(input_model: str, output_model: str)[source]

Convert DP graph to 2.1 graph.

Parameters:
input_modelstr

filename of the input graph

output_modelstr

filename of the output graph

deepmd.utils.convert.detect_model_version(input_model: str)[source]

Detect DP graph version.

Parameters:
input_modelstr

filename of the input graph

## deepmd.utils.data module

class deepmd.utils.data.DeepmdData(sys_path: str, set_prefix: str = 'set', shuffle_test: bool = True, type_map: List[str] | None = None, optional_type_map: bool = True, modifier=None, trn_all_set: bool = False)[source]

Bases: object

Class for a data system.

It loads data from hard disk, and mantains the data as a data_dict

Parameters:
sys_path

Path to the data system

set_prefix

Prefix for the directories of different sets

shuffle_test

If the test data are shuffled

type_map

Gives the name of different atom types

optional_type_map

If the type_map.raw in each system is optional

modifier

Data modifier that has the method modify_data

trn_all_set

Use all sets as training dataset. Otherwise, if the number of sets is more than 1, the last set is left for test.

Methods

 add(key, ndof[, atomic, must, high_prec, ...]) Add a data item that to be loaded. avg(key) Return the average value of an item. check_batch_size(batch_size) Check if the system can get a batch of data with batch_size frames. check_test_size(test_size) Check if the system can get a test dataset with test_size frames. Get atom types. get_batch(batch_size) Get a batch of data with batch_size frames. Get the data_dict. Get number of atoms. get_natoms_vec(ntypes) Get number of atoms and number of atoms in different types. Number of atom types in the system. get_numb_batch(batch_size, set_idx) Get the number of batches in a set. Get number of training sets. get_sys_numb_batch(batch_size) Get the number of batches in the data system. get_test([ntests]) Get the test data with ntests frames. Get the type map. reduce(key_out, key_in) Generate a new item from the reduction of another atom.
 reset_get_batch
add(key: str, ndof: int, atomic: bool = False, must: bool = False, high_prec: bool = False, type_sel: List[int] | None = None, repeat: int = 1, default: float = 0.0, dtype: = None)[source]

Parameters:
key

The key of the item. The corresponding data is stored in sys_path/set.*/key.npy

ndof

The number of dof

atomic

The item is an atomic property. If False, the size of the data should be nframes x ndof If True, the size of data should be nframes x natoms x ndof

must

The data file sys_path/set.*/key.npy must exist. If must is False and the data file does not exist, the data_dict[find_key] is set to 0.0

high_prec

Load the data and store in float64, otherwise in float32

type_sel

Select certain type of atoms

repeat

The data will be repeated repeat times.

defaultfloat, default=0.

default value of data

dtypenp.dtype, optional

the dtype of data, overwrites high_prec if provided

avg(key)[source]

Return the average value of an item.

check_batch_size(batch_size)[source]

Check if the system can get a batch of data with batch_size frames.

check_test_size(test_size)[source]

Check if the system can get a test dataset with test_size frames.

get_atom_type() List[int][source]

Get atom types.

get_batch(batch_size: int) dict[source]

Get a batch of data with batch_size frames. The frames are randomly picked from the data system.

Parameters:
batch_size

size of the batch

get_data_dict() dict[source]

Get the data_dict.

get_natoms()[source]

Get number of atoms.

get_natoms_vec(ntypes: int)[source]

Get number of atoms and number of atoms in different types.

Parameters:
ntypes

Number of types (may be larger than the actual number of types in the system).

Returns:
natoms

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

get_ntypes() int[source]

Number of atom types in the system.

get_numb_batch(batch_size: int, set_idx: int) int[source]

Get the number of batches in a set.

get_numb_set() int[source]

Get number of training sets.

get_sys_numb_batch(batch_size: int) int[source]

Get the number of batches in the data system.

get_test(ntests: int = -1) dict[source]

Get the test data with ntests frames.

Parameters:
ntests

Size of the test data set. If ntests is -1, all test data will be get.

get_type_map() List[str][source]

Get the type map.

reduce(key_out: str, key_in: str)[source]

Generate a new item from the reduction of another atom.

Parameters:
key_out

The name of the reduced item

key_in

The name of the data item to be reduced

reset_get_batch()[source]

## deepmd.utils.data_system module

class deepmd.utils.data_system.DeepmdDataSystem(systems: List[str], batch_size: int, test_size: int, rcut: float, set_prefix: str = 'set', shuffle_test: bool = True, type_map: List[str] | None = None, optional_type_map: bool = True, modifier=None, trn_all_set=False, sys_probs=None, auto_prob_style='prob_sys_size')[source]

Bases: object

Class for manipulating many data systems.

It is implemented with the help of DeepmdData

Methods

 add(key, ndof[, atomic, must, high_prec, ...]) Add a data item that to be loaded. add_dict(adict) Add items to the data system by a dict. get_batch([sys_idx]) Get a batch of data from the data systems. Get a batch of data from the data systems in the mixed way. Get the batch size. get_batch_standard([sys_idx]) Get a batch of data from the data systems in the standard way. Get the total number of batches. Get the number of data systems. Get the number of types. get_sys(idx) Get a certain data system. get_sys_ntest([sys_idx]) Get number of tests for the currently selected system, or one defined by sys_idx. get_test([sys_idx, n_test]) Get test data from the the data systems. Get the type map. reduce(key_out, key_in) Generate a new item from the reduction of another atom.
 compute_energy_shift get_data_dict print_summary set_sys_probs
add(key: str, ndof: int, atomic: bool = False, must: bool = False, high_prec: bool = False, type_sel: List[int] | None = None, repeat: int = 1, default: float = 0.0)[source]

Parameters:
key

The key of the item. The corresponding data is stored in sys_path/set.*/key.npy

ndof

The number of dof

atomic

The item is an atomic property. If False, the size of the data should be nframes x ndof If True, the size of data should be nframes x natoms x ndof

must

The data file sys_path/set.*/key.npy must exist. If must is False and the data file does not exist, the data_dict[find_key] is set to 0.0

high_prec

Load the data and store in float64, otherwise in float32

type_sel

Select certain type of atoms

repeat

The data will be repeated repeat times.

default, default=0.

Default value of data

Add items to the data system by a dict. adict should have items like .. code-block:: python.

“ndof”: ndof, “atomic”: atomic, “must”: must, “high_prec”: high_prec, “type_sel”: type_sel, “repeat”: repeat,

}

For the explaination of the keys see add

compute_energy_shift(rcond=0.001, key='energy')[source]
get_batch(sys_idx: = None) dict[source]

Get a batch of data from the data systems.

Parameters:
sys_idxint

The index of system from which the batch is get. If sys_idx is not None, sys_probs and auto_prob_style are ignored If sys_idx is None, automatically determine the system according to sys_probs or auto_prob_style, see the following. This option does not work for mixed systems.

Returns:
dict

The batch data

get_batch_mixed() dict[source]

Get a batch of data from the data systems in the mixed way.

Returns:
dict

The batch data

get_batch_size() int[source]

Get the batch size.

get_batch_standard(sys_idx: = None) dict[source]

Get a batch of data from the data systems in the standard way.

Parameters:
sys_idxint

The index of system from which the batch is get. If sys_idx is not None, sys_probs and auto_prob_style are ignored If sys_idx is None, automatically determine the system according to sys_probs or auto_prob_style, see the following.

Returns:
dict

The batch data

get_data_dict(ii: int = 0) dict[source]
get_nbatches() int[source]

Get the total number of batches.

get_nsystems() int[source]

Get the number of data systems.

get_ntypes() int[source]

Get the number of types.

get_sys(idx: int) [source]

Get a certain data system.

get_sys_ntest(sys_idx=None)[source]

Get number of tests for the currently selected system, or one defined by sys_idx.

get_test(sys_idx: = None, n_test: int = -1)[source]

Get test data from the the data systems.

Parameters:
sys_idx

The test dat of system with index sys_idx will be returned. If is None, the currently selected system will be returned.

n_test

Number of test data. If set to -1 all test data will be get.

get_type_map() List[str][source]

Get the type map.

print_summary(name)[source]
reduce(key_out, key_in)[source]

Generate a new item from the reduction of another atom.

Parameters:
key_out

The name of the reduced item

key_in

The name of the data item to be reduced

set_sys_probs(sys_probs=None, auto_prob_style: str = 'prob_sys_size')[source]

## deepmd.utils.errors module

exception deepmd.utils.errors.GraphTooLargeError[source]

Bases: Exception

The graph is too large, exceeding protobuf’s hard limit of 2GB.

exception deepmd.utils.errors.GraphWithoutTensorError[source]

Bases: Exception

exception deepmd.utils.errors.OutOfMemoryError[source]

Bases: Exception

This error is caused by out-of-memory (OOM).

## deepmd.utils.finetune module

deepmd.utils.finetune.replace_model_params_with_pretrained_model(jdata: Dict[str, Any], pretrained_model: str)[source]

Replace the model params in input script according to pretrained model.

Parameters:
jdata

input script

pretrained_modelstr

filename of the pretrained model

## deepmd.utils.graph module

deepmd.utils.graph.get_attention_layer_nodes_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the attention layer nodes with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffixstr, optional

The scope suffix

Returns:
Dict

The attention layer nodes within the given tf.GraphDef object

deepmd.utils.graph.get_attention_layer_variables_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the attention layer variables with the given tf.GraphDef object.

Parameters:
graph_deftf.GraphDef

The input tf.GraphDef object

suffixstr, optional

The suffix of the scope

Returns:
Dict

The attention layer variables within the given tf.GraphDef object

deepmd.utils.graph.get_embedding_net_nodes(model_file: str, suffix: str = '') Dict[source]

Get the embedding net nodes with the given frozen model(model_file).

Parameters:
model_file

The input frozen model path

suffixstr, optional

The suffix of the scope

Returns:
Dict

The embedding net nodes with the given frozen model

deepmd.utils.graph.get_embedding_net_nodes_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the embedding net nodes with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffixstr, optional

The scope suffix

Returns:
Dict

The embedding net nodes within the given tf.GraphDef object

deepmd.utils.graph.get_embedding_net_variables(model_file: str, suffix: str = '') Dict[source]

Get the embedding net variables with the given frozen model(model_file).

Parameters:
model_file

The input frozen model path

suffixstr, optional

The suffix of the scope

Returns:
Dict

The embedding net variables within the given frozen model

deepmd.utils.graph.get_embedding_net_variables_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the embedding net variables with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffixstr, optional

The suffix of the scope

Returns:
Dict

The embedding net variables within the given tf.GraphDef object

deepmd.utils.graph.get_fitting_net_nodes(model_file: str) Dict[source]

Get the fitting net nodes with the given frozen model(model_file).

Parameters:
model_file

The input frozen model path

Returns:
Dict

The fitting net nodes with the given frozen model

deepmd.utils.graph.get_fitting_net_nodes_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the fitting net nodes with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffix

suffix of the scope

Returns:
Dict

The fitting net nodes within the given tf.GraphDef object

deepmd.utils.graph.get_fitting_net_variables(model_file: str, suffix: str = '') Dict[source]

Get the fitting net variables with the given frozen model(model_file).

Parameters:
model_file

The input frozen model path

suffix

suffix of the scope

Returns:
Dict

The fitting net variables within the given frozen model

deepmd.utils.graph.get_fitting_net_variables_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the fitting net variables with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffix

suffix of the scope

Returns:
Dict

The fitting net variables within the given tf.GraphDef object

deepmd.utils.graph.get_pattern_nodes_from_graph_def(graph_def: GraphDef, pattern: str) Dict[source]

Get the pattern nodes with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

pattern

The node pattern within the graph_def

Returns:
Dict

The fitting net nodes within the given tf.GraphDef object

deepmd.utils.graph.get_tensor_by_name(model_file: str, tensor_name: str) Tensor[source]

Load tensor value from the frozen model(model_file).

Parameters:
model_filestr

The input frozen model path

tensor_namestr

Indicates which tensor which will be loaded from the frozen model

Returns:
tf.Tensor

The tensor which was loaded from the frozen model

Raises:
GraphWithoutTensorError

Whether the tensor_name is within the frozen model

deepmd.utils.graph.get_tensor_by_name_from_graph(graph: Graph, tensor_name: str) Tensor[source]

Load tensor value from the given tf.Graph object.

Parameters:
graphtf.Graph

The input TensorFlow graph

tensor_namestr

Indicates which tensor which will be loaded from the frozen model

Returns:
tf.Tensor

The tensor which was loaded from the frozen model

Raises:
GraphWithoutTensorError

Whether the tensor_name is within the frozen model

deepmd.utils.graph.get_tensor_by_type(node, data_type: dtype) Tensor[source]

Get the tensor value within the given node according to the input data_type.

Parameters:
node

The given tensorflow graph node

data_type

The data type of the node

Returns:
tf.Tensor

The tensor value of the given node

deepmd.utils.graph.get_type_embedding_net_nodes_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the type embedding net nodes with the given tf.GraphDef object.

Parameters:
graph_def

The input tf.GraphDef object

suffixstr, optional

The scope suffix

Returns:
Dict

The type embedding net nodes within the given tf.GraphDef object

deepmd.utils.graph.get_type_embedding_net_variables_from_graph_def(graph_def: GraphDef, suffix: str = '') Dict[source]

Get the type embedding net variables with the given tf.GraphDef object.

Parameters:
graph_deftf.GraphDef

The input tf.GraphDef object

suffixstr, optional

The suffix of the scope

Returns:
Dict

The embedding net variables within the given tf.GraphDef object

Load graph as well as the graph_def from the frozen model(model_file).

Parameters:
model_filestr

The input frozen model path

Returns:
tf.Graph

The graph loaded from the frozen model

tf.GraphDef

The graph_def loaded from the frozen model

## deepmd.utils.learning_rate module

class deepmd.utils.learning_rate.LearningRateExp(start_lr: float, stop_lr: float = 5e-08, decay_steps: int = 5000, decay_rate: float = 0.95)[source]

Bases: object

The exponentially decaying learning rate.

The learning rate at step $$t$$ is given by

$\alpha(t) = \alpha_0 \lambda ^ { t / \tau }$

where $$\alpha$$ is the learning rate, $$\alpha_0$$ is the starting learning rate, $$\lambda$$ is the decay rate, and $$\tau$$ is the decay steps.

Parameters:
start_lr

Starting learning rate $$\alpha_0$$

stop_lr

Stop learning rate $$\alpha_1$$

decay_steps

Learning rate decay every this number of steps $$\tau$$

decay_rate

The decay rate $$\lambda$$. If stop_step is provided in build, then it will be determined automatically and overwritten.

Methods

 build(global_step[, stop_step]) Build the learning rate. Get the start lr. value(step) Get the lr at a certain step.
build(global_step: Tensor, stop_step: = None) Tensor[source]

Build the learning rate.

Parameters:
global_step

The tf Tensor prividing the global training step

stop_step

The stop step. If provided, the decay_rate will be determined automatically and overwritten.

Returns:
learning_rate

The learning rate

start_lr() [source]

Get the start lr.

value(step: int) [source]

Get the lr at a certain step.

## deepmd.utils.multi_init module

deepmd.utils.multi_init.replace_model_params_with_frz_multi_model(jdata: Dict[str, Any], pretrained_model: str)[source]

Replace the model params in input script according to pretrained frozen multi-task united model.

Parameters:
jdata

input script

pretrained_modelstr

filename of the pretrained frozen multi-task united model

## deepmd.utils.neighbor_stat module

class deepmd.utils.neighbor_stat.NeighborStat(ntypes: int, rcut: float, one_type: bool = False)[source]

Bases: object

Class for getting training data information.

It loads data from DeepmdData object, and measures the data info, including neareest nbor distance between atoms, max nbor size of atoms and the output data range of the environment matrix.

Parameters:
ntypes

The num of atom types

rcut

one_typebool, optional, default=False

Treat all types as a single type.

Methods

 get_stat(data) get the data statistics of the training data, including nearest nbor distance between atoms, max nbor size of atoms.
get_stat(data: DeepmdDataSystem) Tuple[float, List[int]][source]

get the data statistics of the training data, including nearest nbor distance between atoms, max nbor size of atoms.

Parameters:
data

Class for manipulating many data systems. It is implemented with the help of DeepmdData.

Returns:
min_nbor_dist

The nearest distance between neighbor atoms

max_nbor_size

A list with ntypes integers, denotes the actual achieved max sel

## deepmd.utils.network module

deepmd.utils.network.embedding_net(xx, network_size, precision, activation_fn=<function tanh>, resnet_dt=False, name_suffix='', stddev=1.0, bavg=0.0, seed=None, trainable=True, uniform_seed=False, initial_variables=None, mixed_prec=None)[source]

The embedding network.

The embedding network function $$\mathcal{N}$$ is constructed by is the composition of multiple layers $$\mathcal{L}^{(i)}$$:

$\mathcal{N} = \mathcal{L}^{(n)} \circ \mathcal{L}^{(n-1)} \circ \cdots \circ \mathcal{L}^{(1)}$

A layer $$\mathcal{L}$$ is given by one of the following forms, depending on the number of nodes: [1]

$\begin{split}\mathbf{y}=\mathcal{L}(\mathbf{x};\mathbf{w},\mathbf{b})= \begin{cases} \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b}) + \mathbf{x}, & N_2=N_1 \\ \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b}) + (\mathbf{x}, \mathbf{x}), & N_2 = 2N_1\\ \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b}), & \text{otherwise} \\ \end{cases}\end{split}$

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 is True. $$\boldsymbol{\phi}$$ is the activation function.

Parameters:
xxTensor

Input tensor $$\mathbf{x}$$ of shape [-1,1]

network_sizelist of int

Size of the embedding network. For example [16,32,64]

precision:

Precision of network weights. For example, tf.float64

activation_fn:

Activation function $$\boldsymbol{\phi}$$

resnet_dtbool

Using time-step in the ResNet construction

name_suffixstr

The name suffix append to each variable.

stddevfloat

Standard deviation of initializing network parameters

bavgfloat

Mean of network intial bias

seedint

Random seed for initializing network parameters

trainablebool

If the network is trainable

uniform_seedbool

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

initial_variablesdict

The input dict which stores the embedding net variables

mixed_prec

The input dict which stores the mixed precision setting for the embedding net

References

[1]

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identitymappings in deep residual networks. InComputer Vision – ECCV 2016,pages 630–645. Springer International Publishing, 2016.

deepmd.utils.network.embedding_net_rand_seed_shift(network_size)[source]
deepmd.utils.network.one_layer(inputs, outputs_size, activation_fn=<function tanh>, precision=tf.float64, stddev=1.0, bavg=0.0, name='linear', scope='', reuse=None, seed=None, use_timestep=False, trainable=True, useBN=False, uniform_seed=False, initial_variables=None, mixed_prec=None, final_layer=False)[source]
deepmd.utils.network.one_layer_rand_seed_shift()[source]
deepmd.utils.network.variable_summaries(var: VariableV1, name: str)[source]

Attach a lot of summaries to a Tensor (for TensorBoard visualization).

Parameters:
vartf.Variable

[description]

namestr

variable name

## deepmd.utils.pair_tab module

class deepmd.utils.pair_tab.PairTab(filename: str)[source]

Bases: object

Parameters:
filename

File name for the short-range tabulated potential. The table is a text data file with (N_t + 1) * N_t / 2 + 1 columes. The first colume is the distance between atoms. The second to the last columes are energies for pairs of certain types. For example we have two atom types, 0 and 1. The columes from 2nd to 4th are for 0-0, 0-1 and 1-1 correspondingly.

Methods

 Get the serialized table. reinit(filename) Initialize the tabulated interaction.
get() Tuple[array, array][source]

Get the serialized table.

reinit(filename: str) None[source]

Initialize the tabulated interaction.

Parameters:
filename

File name for the short-range tabulated potential. The table is a text data file with (N_t + 1) * N_t / 2 + 1 columes. The first colume is the distance between atoms. The second to the last columes are energies for pairs of certain types. For example we have two atom types, 0 and 1. The columes from 2nd to 4th are for 0-0, 0-1 and 1-1 correspondingly.

## deepmd.utils.parallel_op module

class deepmd.utils.parallel_op.ParallelOp(builder: Callable[[...], Tuple[Dict[str, Tensor], Tuple[Tensor]]], nthreads: = None, config: ConfigProto | None = None)[source]

Bases: object

Run an op with data parallelism.

Parameters:
builder

returns two objects: a dict which stores placeholders by key, and a tuple with the final op(s)

nthreadsint, optional

configtf.ConfigProto, optional

tf.ConfigProto

Examples

>>> from deepmd.env import tf
>>> from deepmd.utils.parallel_op import ParallelOp
>>> def builder():
...     x = tf.placeholder(tf.int32, [1])
...     return {"x": x}, (x + 1)
...
>>> def feed():
...     for ii in range(10):
...         yield {"x": [ii]}
...
>>> print(*p.generate(tf.Session(), feed()))
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]


Methods

 generate(sess, feed) Returns a generator.
generate(sess: Session, feed: Generator[Dict[str, Any], None, None]) [source]

Returns a generator.

Parameters:
sesstf.Session

TensorFlow session

feed

generator which yields feed_dict

Yields:
Generator[Tuple, None, None]

generator which yields session returns

## deepmd.utils.path module

class deepmd.utils.path.DPH5Path(path: str)[source]

Bases: DPPath

The path class to data system (DeepmdData) for HDF5 files.

Parameters:
pathstr

path

Notes

OS - HDF5 relationship:

directory - Group file - Dataset

Methods

 glob(pattern) Search path using the glob pattern. Check if self is directory. Check if self is file. Load NumPy array. load_txt([dtype]) Load NumPy array from text. rglob(pattern) This is like calling DPPath.glob() with **/ added in front of the given relative pattern.
glob(pattern: str) [source]

Search path using the glob pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

is_dir() bool[source]

Check if self is directory.

is_file() bool[source]

Check if self is file.

Returns:
np.ndarray

Returns:
np.ndarray

rglob(pattern: str) [source]

This is like calling DPPath.glob() with **/ added in front of the given relative pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

class deepmd.utils.path.DPOSPath(path: str)[source]

Bases: DPPath

The OS path class to data system (DeepmdData) for real directories.

Parameters:
pathstr

path

Methods

 glob(pattern) Search path using the glob pattern. Check if self is directory. Check if self is file. Load NumPy array. load_txt(**kwargs) Load NumPy array from text. rglob(pattern) This is like calling DPPath.glob() with **/ added in front of the given relative pattern.
glob(pattern: str) [source]

Search path using the glob pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

is_dir() bool[source]

Check if self is directory.

is_file() bool[source]

Check if self is file.

Returns:
np.ndarray

Returns:
np.ndarray

rglob(pattern: str) [source]

This is like calling DPPath.glob() with **/ added in front of the given relative pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

class deepmd.utils.path.DPPath(path: str)[source]

Bases: ABC

The path class to data system (DeepmdData).

Parameters:
pathstr

path

Methods

 glob(pattern) Search path using the glob pattern. Check if self is directory. Check if self is file. Load NumPy array. load_txt(**kwargs) Load NumPy array from text. rglob(pattern) This is like calling DPPath.glob() with **/ added in front of the given relative pattern.
abstract glob(pattern: str) [source]

Search path using the glob pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

abstract is_dir() bool[source]

Check if self is directory.

abstract is_file() bool[source]

Check if self is file.

Returns:
np.ndarray

Returns:
np.ndarray

abstract rglob(pattern: str) [source]

This is like calling DPPath.glob() with **/ added in front of the given relative pattern.

Parameters:
patternstr

glob pattern

Returns:
List[DPPath]

list of paths

## deepmd.utils.plugin module

Base of plugin systems.

class deepmd.utils.plugin.Plugin[source]

Bases: object

A class to register and restore plugins.

Examples

>>> plugin = Plugin()
>>> @plugin.register("xx")
def xxx():
pass
>>> print(plugin.plugins['xx'])

Attributes:
plugins

plugins

Methods

 get_plugin(key) Visit a plugin by key. register(key) Register a plugin.
get_plugin(key) [source]

Visit a plugin by key.

Parameters:
keystr

key of the plugin

Returns:
object

the plugin

register(key: str) Callable[[object], object][source]

Register a plugin.

Parameters:
keystr

key of the plugin

Returns:
Callable[[object], object]

decorator

class deepmd.utils.plugin.PluginVariant(*args, **kwargs)[source]

Bases: object

A class to remove type from input arguments.

class deepmd.utils.plugin.VariantABCMeta(name, bases, namespace, **kwargs)[source]

Methods

 __call__(*args, **kwargs) Remove type and keys that starts with underline. mro(/) Return a type's method resolution order. register(subclass) Register a virtual subclass of an ABC.
class deepmd.utils.plugin.VariantMeta[source]

Bases: object

Methods

 __call__(*args, **kwargs) Remove type and keys that starts with underline.

## deepmd.utils.random module

deepmd.utils.random.choice(a: ndarray, p: = None)[source]

Generates a random sample from a given 1-D array.

Parameters:
anp.ndarray

A random sample is generated from its elements.

pnp.ndarray

The probabilities associated with each entry in a.

Returns:
np.ndarray

arrays with results and their shapes

deepmd.utils.random.random(size=None)[source]

Return random floats in the half-open interval [0.0, 1.0).

Parameters:
size

Output shape.

Returns:
np.ndarray

Arrays with results and their shapes.

deepmd.utils.random.seed(val: = None)[source]

Seed the generator.

Parameters:
valint

Seed.

deepmd.utils.random.shuffle(x: ndarray)[source]

Modify a sequence in-place by shuffling its contents.

Parameters:
xnp.ndarray

The array or list to be shuffled.

## deepmd.utils.sess module

deepmd.utils.sess.run_sess(sess: Session, *args, **kwargs)[source]

Run session with erorrs caught.

Parameters:
sesstf.Session

TensorFlow Session

*args

Variable length argument list.

**kwargs

Arbitrary keyword arguments.

Returns:
Any

the result of sess.run()

## deepmd.utils.tabulate module

class deepmd.utils.tabulate.DPTabulate(descrpt: ~deepmd.descriptor.descriptor.Descriptor, neuron: ~typing.List[int], graph: ~tensorflow.python.framework.ops.Graph, graph_def: ~tensorflow.core.framework.graph_pb2.GraphDef, type_one_side: bool = False, exclude_types: ~typing.List[~typing.List[int]] = [], activation_fn: ~typing.Callable[[~tensorflow.python.framework.ops.Tensor], ~tensorflow.python.framework.ops.Tensor] = <function tanh>, suffix: str = '')[source]

Bases: object

Class for tabulation.

Compress a model, which including tabulating the embedding-net. The table is composed of fifth-order polynomial coefficients and is assembled from two sub-tables. The first table takes the stride(parameter) as it’s uniform stride, while the second table takes 10 * stride as it’s uniform stride The range of the first table is automatically detected by deepmd-kit, while the second table ranges from the first table’s upper boundary(upper) to the extrapolate(parameter) * upper.

Parameters:
descrpt

Descriptor of the original model

neuron

Number of neurons in each hidden layers of the embedding net $$\\mathcal{N}$$

graphtf.Graph

The graph of the original model

graph_deftf.GraphDef

The graph_def of the original model

type_one_side

Try to build N_types tables. Otherwise, building N_types^2 tables

exclude_types

The excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.

activation_function

The activation function in the embedding net. Supported options are {“tanh”,”gelu”} in common.ACTIVATION_FN_DICT.

suffixstr, optional

The suffix of the scope

Methods

 build(min_nbor_dist, extrapolate, stride0, ...) Build the tables for model compression.
build(min_nbor_dist: float, extrapolate: float, stride0: float, stride1: float) Tuple[Dict[str, int], Dict[str, int]][source]

Build the tables for model compression.

Parameters:
min_nbor_dist

The nearest distance between neighbor atoms

extrapolate

The scale of model extrapolation

stride0

The uniform stride of the first table

stride1

The uniform stride of the second table

Returns:
lower

The lower boundary of environment matrix by net

upper

The upper boundary of environment matrix by net

## deepmd.utils.type_embed module

class deepmd.utils.type_embed.TypeEmbedNet(neuron: List[int] = [], resnet_dt: bool = False, activation_function: = 'tanh', precision: str = 'default', trainable: bool = True, seed: = None, uniform_seed: bool = False, padding: bool = False)[source]

Bases: object

Type embedding network.

Parameters:
neuron

Number of neurons in each hidden layers of the embedding net

resnet_dt

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

activation_function

The activation function 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”.

trainable

If the weights of embedding net are trainable.

seed

Random seed for initializing the network parameters.

uniform_seed

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

Concat the zero padding to the output, as the default embedding of empty type.

Methods

 build(ntypes[, reuse, suffix]) Build the computational graph for the descriptor. init_variables(graph, graph_def[, suffix]) Init the type embedding net variables with the given dict.
build(ntypes: int, reuse=None, suffix='')[source]

Build the computational graph for the descriptor.

Parameters:
ntypes

Number of atom types.

reuse

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

suffix

Name suffix to identify this descriptor

Returns:
embedded_types

The computational graph for embedded types

init_variables(graph: Graph, graph_def: GraphDef, suffix='') None[source]

Init the type embedding net variables with the given dict.

Parameters:
graphtf.Graph

The input frozen model graph

graph_deftf.GraphDef

The input frozen model graph_def

suffix

Name suffix to identify this descriptor

deepmd.utils.type_embed.embed_atom_type(ntypes: int, natoms: Tensor, type_embedding: Tensor)[source]

Make the embedded type for the atoms in system. The atoms are assumed to be sorted according to the type, thus their types are described by a tf.Tensor natoms, see explanation below.

Parameters:
ntypes:

Number of types.

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

type_embedding:

The type embedding. It has the shape of [ntypes, embedding_dim]

Returns:
atom_embedding

The embedded type of each atom. It has the shape of [numb_atoms, embedding_dim]

## deepmd.utils.weight_avg module

deepmd.utils.weight_avg.weighted_average(errors: List[Dict[str, Tuple[float, float]]]) Dict[source]

Compute wighted average of prediction errors (MAE or RMSE) for model.

Parameters:
errors

List: the error of systems Dict: the error of quantities, name given by the key str: the name of the quantity, must starts with ‘mae’ or ‘rmse’ Tuple: (error, weight)

Returns:
Dict

weighted averages