deepmd.tf.entrypoints

Submodule that contains all the DeePMD-Kit entry point scripts.

Submodules

Functions

`make_model_devi`(*, models, system, output, frequency)	Make model deviation calculation.
`compress`(*, input, output, extrapolate, step, ...)	Compress model.
`convert`(, FROM, input_model, output_model, *kwargs)
`doc_train_input`(*[, out_type, multi_task])	Print out trining input arguments to console.
`freeze`(*, checkpoint_folder, output[, node_names, ...])	Freeze the graph in supplied folder.
`start_dpgui`(, port, bind_all, *kwargs)	Host DP-GUI server.
`neighbor_stat`(*, system, rcut, type_map[, mixed_type, ...])	Calculate neighbor statistics.
`test`(*, model, system, datafile, numb_test, rand_seed, ...)	Test model predictions.
`train_dp`(*, INPUT, init_model, restart, output, ...[, ...])	Run DeePMD model training.
`transfer`(, old_model, raw_model, output, *kwargs)	Transfer operation from old fron graph to new prepared raw graph.

Package Contents

deepmd.tf.entrypoints.make_model_devi(*, models: list, system: str, output: str, frequency: int, real_error: bool = False, atomic: bool = False, relative: float | None = None, relative_v: float | None = None, **kwargs)[source]

Make model deviation calculation.

Parameters:

modelslist: A list of paths of models to use for making model deviation
systemstr: The path of system to make model deviation calculation
outputstr: The output file for model deviation results
frequencyint: The number of steps that elapse between writing coordinates in a trajectory by a MD engine (such as Gromacs / LAMMPS). This paramter is used to determine the index in the output file.
real_errorbool, default: False: If True, calculate the RMS real error instead of model deviation.
atomicbool, default: False: If True, calculate the force model deviation of each atom.
relativefloat, default: None: If given, calculate the relative model deviation of force. The value is the level parameter for computing the relative model deviation of the force.
relative_vfloat, default: None: If given, calculate the relative model deviation of virial. The value is the level parameter for computing the relative model deviation of the virial.
**kwargs: Arbitrary keyword arguments.

deepmd.tf.entrypoints.compress(*, input: str, output: str, extrapolate: int, step: float, frequency: str, checkpoint_folder: str, training_script: str, mpi_log: str, log_path: str | None, log_level: int, **kwargs)[source]

Compress model.

The table is composed of fifth-order polynomial coefficients and is assembled from two sub-tables. The first table takes the step parameter as the domain’s uniform step size, while the second table takes 10 * step as it’s uniform step size. The range of the first table is automatically detected by the code, while the second table ranges from the first table’s upper boundary(upper) to the extrapolate(parameter) * upper.

Parameters:

inputstr: frozen model file to compress
outputstr: compressed model filename
extrapolateint: scale of model extrapolation
stepfloat: uniform step size of the tabulation’s first table
frequencystr: frequency of tabulation overflow check
checkpoint_folderstr: trining checkpoint folder for freezing
training_scriptstr: training script of the input frozen model
mpi_logstr: mpi logging mode for training
log_pathOptional[str]: if speccified log will be written to this file
log_levelint: logging level
**kwargs: additional arguments

deepmd.tf.entrypoints.convert(*, FROM: str, input_model: str, output_model: str, **kwargs)[source]

deepmd.tf.entrypoints.doc_train_input(*, out_type: str = 'rst', multi_task: bool = False, **kwargs)[source]: Print out trining input arguments to console.

deepmd.tf.entrypoints.freeze(*, checkpoint_folder: str, output: str, node_names: str | None = None, nvnmd_weight: str | None = None, **kwargs)[source]

Freeze the graph in supplied folder.

Parameters:

checkpoint_folderstr: location of either the folder with checkpoint or the checkpoint prefix
outputstr: output file name
node_namesOptional[str], optional: names of nodes to output, by default None
nvnmd_weightOptional[str], optional: nvnmd weight file
**kwargs: other arguments

deepmd.tf.entrypoints.start_dpgui(*, port: int, bind_all: bool, **kwargs)[source]

Host DP-GUI server.

Parameters:

portint: The port to serve DP-GUI on.
bind_allbool: Serve on all public interfaces. This will expose your DP-GUI instance to the network on both IPv4 and IPv6 (where available).
**kwargs: additional arguments

Raises:

ModuleNotFoundError: The dpgui package is not installed

deepmd.tf.entrypoints.neighbor_stat(*, system: str, rcut: float, type_map: List[str], mixed_type: bool = False, backend: str = 'tensorflow', **kwargs)[source]

Calculate neighbor statistics.

Parameters:

systemstr: system to stat
rcutfloat: cutoff radius
type_maplist[str]: type map
mixed_typebool, optional, default=False: treat all types as a single type
backendstr, optional, default=”tensorflow”: backend to use
**kwargs: additional arguments

Examples

>>> neighbor_stat(
...     system=".",
...     rcut=6.0,
...     type_map=[
...         "C",
...         "H",
...         "O",
...         "N",
...         "P",
...         "S",
...         "Mg",
...         "Na",
...         "HW",
...         "OW",
...         "mNa",
...         "mCl",
...         "mC",
...         "mH",
...         "mMg",
...         "mN",
...         "mO",
...         "mP",
...     ],
... )
min_nbor_dist: 0.6599510670195264
max_nbor_size: [23, 26, 19, 16, 2, 2, 1, 1, 72, 37, 5, 0, 31, 29, 1, 21, 20, 5]

deepmd.tf.entrypoints.test(*, model: str, system: str, datafile: str, numb_test: int, rand_seed: int | None, shuffle_test: bool, detail_file: str, atomic: bool, head: str | None = None, **kwargs)[source]

Test model predictions.

Parameters:

modelstr: path where model is stored
systemstr: system directory
datafilestr: the path to the list of systems to test
numb_testint: munber of tests to do. 0 means all data.
rand_seedOptional[int]: seed for random generator
shuffle_testbool: whether to shuffle tests
detail_fileOptional[str]: file where test details will be output
atomicbool: whether per atom quantities should be computed
headOptional[str], optional: (Supported backend: PyTorch) Task head to test if in multi-task mode.
**kwargs: additional arguments

Raises:

RuntimeError: if no valid system was found

deepmd.tf.entrypoints.train_dp(*, INPUT: str, init_model: str | None, restart: str | None, output: str, init_frz_model: str, mpi_log: str, log_level: int, log_path: str | None, is_compress: bool = False, skip_neighbor_stat: bool = False, finetune: str | None = None, use_pretrain_script: bool = False, **kwargs)

Run DeePMD model training.

Parameters:

INPUTstr: json/yaml control file
init_modelOptional[str]: path prefix of checkpoint files or None
restartOptional[str]: path prefix of checkpoint files or None
outputstr: path for dump file with arguments
init_frz_modelstr: path to frozen model or None
mpi_logstr: mpi logging mode
log_levelint: logging level defined by int 0-3
log_pathOptional[str]: logging file path or None if logs are to be output only to stdout
is_compressbool: indicates whether in the model compress mode
skip_neighbor_statbool, default=False: skip checking neighbor statistics
finetuneOptional[str]: path to pretrained model or None
use_pretrain_scriptbool: Whether to use model script in pretrained model when doing init-model or init-frz-model. Note that this option is true and unchangeable for fine-tuning.
**kwargs: additional arguments

Raises:

RuntimeError: if distributed training job name is wrong

deepmd.tf.entrypoints.transfer(*, old_model: str, raw_model: str, output: str, **kwargs)[source]

Transfer operation from old fron graph to new prepared raw graph.

Parameters:

old_modelstr: frozen old graph model
raw_modelstr: new model that will accept ops from old model
outputstr: new model with transfered parameters will be saved to this location
**kwargs: additional arguments