DeePMD-kit’s documentation
DeePMD-kit is a package written in Python/C++, designed to minimize the effort required to build deep learning-based models of interatomic potential energy and force field and to perform molecular dynamics (MD). This brings new hopes to addressing the accuracy-versus-efficiency dilemma in molecular simulations. Applications of DeePMD-kit span from finite molecules to extended systems and from metallic systems to chemically bonded systems.
Important
The project DeePMD-kit is licensed under GNU LGPLv3.0. If you use this code in any future publications, please cite this using Han Wang, Linfeng Zhang, Jiequn Han, and Weinan E. “DeePMD-kit: A deep learning package for many-body potential energy representation and molecular dynamics.” Computer Physics Communications 228 (2018): 178-184.
Getting Started
In this text, we will call the deep neural network that is used to represent the interatomic interactions (Deep Potential) the model. The typical procedure of using DeePMD-kit is
Easy install
There are various easy methods to install DeePMD-kit. Choose one that you prefer. If you want to build by yourself, jump to the next two sections.
After your easy installation, DeePMD-kit (dp) and LAMMPS (lmp) will be available to execute. You can try dp -h and lmp -h to see the help. mpirun is also available considering you may want to train models or run LAMMPS in parallel.
Note
Note: The off-line packages and conda packages require the GNU C Library 2.17 or above. The GPU version requires compatible NVIDIA driver to be installed in advance. It is possible to force conda to override detection when installation, but these requirements are still necessary during runtime.
Install off-line packages
Both CPU and GPU version offline packages are available in the Releases page.
Some packages are splited into two files due to size limit of GitHub. One may merge them into one after downloading:
cat deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh.0 deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh.1 > deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh
One may enable the environment using
conda activate /path/to/deepmd-kit
Install with conda
DeePMD-kit is avaiable with conda. Install Anaconda or Miniconda first.
Offical channel
One may create an environment that contains the CPU version of DeePMD-kit and LAMMPS:
conda create -n deepmd deepmd-kit=*=*cpu libdeepmd=*=*cpu lammps -c https://conda.deepmodeling.com -c defaults
Or one may want to create a GPU environment containing CUDA Toolkit:
conda create -n deepmd deepmd-kit=*=*gpu libdeepmd=*=*gpu lammps cudatoolkit=11.6 horovod -c https://conda.deepmodeling.com -c defaults
One could change the CUDA Toolkit version from 10.2 or 11.6.
One may specify the DeePMD-kit version such as 2.1.1 using
conda create -n deepmd deepmd-kit=2.1.1=*cpu libdeepmd=2.1.1=*cpu lammps horovod -c https://conda.deepmodeling.com -c defaults
One may enable the environment using
conda activate deepmd
conda-forge channel
DeePMD-kit is also available on the conda-forge channel:
conda create -n deepmd deepmd-kit lammps -c conda-forge
The supported platform includes Linux x86-64, macOS x86-64, and macOS arm64. Read conda-forge FAQ to learn how to install CUDA-enabled packages.
Install with docker
A docker for installing the DeePMD-kit is available here.
To pull the CPU version:
docker pull ghcr.io/deepmodeling/deepmd-kit:2.1.1_cpu
To pull the GPU version:
docker pull ghcr.io/deepmodeling/deepmd-kit:2.1.1_cuda11.6_gpu
To pull the ROCm version:
docker pull deepmodeling/dpmdkit-rocm:dp2.0.3-rocm4.5.2-tf2.6-lmp29Sep2021
Install Python interface with pip
If you have no existing TensorFlow installed, you can use pip to install the pre-built package of the Python interface with CUDA 11 supported:
pip install deepmd-kit[gpu]
Or install the CPU version without CUDA supported:
pip install deepmd-kit[cpu]
LAMMPS module is only provided on Linux and macOS. To enable it, add lmp to extras:
pip install deepmd-kit[gpu,lmp]
MPICH is required for parallel running.
It is suggested to install the package into an isolated environment. The supported platform includes Linux x86-64 and aarch64 with GNU C Library 2.28 or above, macOS x86-64, and Windows x86-64. A specific version of TensorFlow which is compatible with DeePMD-kit will be also installed.
Warning
If your platform is not supported, or want to build against the installed TensorFlow, or want to enable ROCM support, please build from source.
Prepare data with dpdata
One can use a convenient tool dpdata to convert data directly from the output of first principle packages to the DeePMD-kit format.
To install one can execute
pip install dpdata
An example of converting data VASP data in OUTCAR format to DeePMD-kit data can be found at
$deepmd_source_dir/examples/data_conv
Switch to that directory, then one can convert data by using the following python script
import dpdata
dsys = dpdata.LabeledSystem('OUTCAR')
dsys.to('deepmd/npy', 'deepmd_data', set_size = dsys.get_nframes())
get_nframes() method gets the number of frames in the OUTCAR, and the argument set_size enforces that the set size is equal to the number of frames in the system, viz. only one set is created in the system.
The data in DeePMD-kit format is stored in the folder deepmd_data.
A list of all supported data format and more nice features of dpdata can be found on the official website.
Train a model
Several examples of training can be found in the examples directory:
$ cd $deepmd_source_dir/examples/water/se_e2_a/
After switching to that directory, the training can be invoked by
$ dp train input.json
where input.json is the name of the input script.
By default, the verbosity level of the DeePMD-kit is INFO, one may see a lot of important information on the code and environment showing on the screen. Among them two pieces of information regarding data systems are worth special notice.
DEEPMD INFO ---Summary of DataSystem: training -----------------------------------------------
DEEPMD INFO found 3 system(s):
DEEPMD INFO system natoms bch_sz n_bch prob pbc
DEEPMD INFO ../data_water/data_0/ 192 1 80 0.250 T
DEEPMD INFO ../data_water/data_1/ 192 1 160 0.500 T
DEEPMD INFO ../data_water/data_2/ 192 1 80 0.250 T
DEEPMD INFO --------------------------------------------------------------------------------------
DEEPMD INFO ---Summary of DataSystem: validation -----------------------------------------------
DEEPMD INFO found 1 system(s):
DEEPMD INFO system natoms bch_sz n_bch prob pbc
DEEPMD INFO ../data_water/data_3 192 1 80 1.000 T
DEEPMD INFO --------------------------------------------------------------------------------------
The DeePMD-kit prints detailed information on the training and validation data sets. The data sets are defined by training_data and validation_data defined in the training section of the input script. The training data set is composed of three data systems, while the validation data set is composed by one data system. The number of atoms, batch size, the number of batches in the system and the probability of using the system are all shown on the screen. The last column presents if the periodic boundary condition is assumed for the system.
During the training, the error of the model is tested every disp_freq training steps with the batch used to train the model and with numb_btch batches from the validating data. The training error and validation error are printed correspondingly in the file disp_file (default is lcurve.out). The batch size can be set in the input script by the key batch_size in the corresponding sections for the training and validation data set. An example of the output
# step rmse_val rmse_trn rmse_e_val rmse_e_trn rmse_f_val rmse_f_trn lr
0 3.33e+01 3.41e+01 1.03e+01 1.03e+01 8.39e-01 8.72e-01 1.0e-03
100 2.57e+01 2.56e+01 1.87e+00 1.88e+00 8.03e-01 8.02e-01 1.0e-03
200 2.45e+01 2.56e+01 2.26e-01 2.21e-01 7.73e-01 8.10e-01 1.0e-03
300 1.62e+01 1.66e+01 5.01e-02 4.46e-02 5.11e-01 5.26e-01 1.0e-03
400 1.36e+01 1.32e+01 1.07e-02 2.07e-03 4.29e-01 4.19e-01 1.0e-03
500 1.07e+01 1.05e+01 2.45e-03 4.11e-03 3.38e-01 3.31e-01 1.0e-03
The file contains 8 columns, from left to right, which are the training step, the validation loss, training loss, root mean square (RMS) validation error of energy, RMS training error of energy, RMS validation error of force, RMS training error of force and the learning rate. The RMS error (RMSE) of the energy is normalized by the number of atoms in the system. One can visualize this file with a simple Python script:
import numpy as np
import matplotlib.pyplot as plt
data = np.genfromtxt("lcurve.out", names=True)
for name in data.dtype.names[1:-1]:
plt.plot(data['step'], data[name], label=name)
plt.legend()
plt.xlabel('Step')
plt.ylabel('Loss')
plt.xscale('symlog')
plt.yscale('log')
plt.grid()
plt.show()
Checkpoints will be written to files with the prefix save_ckpt every save_freq training steps.
Warning
It is warned that the example water data (in folder examples/water/data) is of very limited amount, is provided only for testing purposes, and should not be used to train a production model.
Freeze a model
The trained neural network is extracted from a checkpoint and dumped into a protobuf(.pb) file. This process is called “freezing” a model. The idea and part of our code are from Morgan. To freeze a model, typically one does
$ dp freeze -o graph.pb
in the folder where the model is trained. The output model is called graph.pb.
In multi-task mode, this process will output several models, each of which contains the common descriptor and one of the user-defined fitting nets in fitting_net_dict, let’s name it fitting_key, together frozen in graph_{fitting_key}.pb. Those frozen models are exactly the same as single-task output with fitting net fitting_key.
Test a model
The frozen model can be used in many ways. The most straightforward test can be performed using dp test. A typical usage of dp test is
dp test -m graph.pb -s /path/to/system -n 30
where -m gives the tested model, -s the path to the tested system and -n the number of tested frames. Several other command line options can be passed to dp test, which can be checked with
$ dp test --help
An explanation will be provided
usage: dp test [-h] [-m MODEL] [-s SYSTEM] [-S SET_PREFIX] [-n NUMB_TEST]
[-r RAND_SEED] [--shuffle-test] [-d DETAIL_FILE]
optional arguments:
-h, --help show this help message and exit
-m MODEL, --model MODEL
Frozen model file to import
-s SYSTEM, --system SYSTEM
The system dir
-S SET_PREFIX, --set-prefix SET_PREFIX
The set prefix
-n NUMB_TEST, --numb-test NUMB_TEST
The number of data for test
-r RAND_SEED, --rand-seed RAND_SEED
The random seed
--shuffle-test Shuffle test data
-d DETAIL_FILE, --detail-file DETAIL_FILE
The prefix to files where details of energy, force and virial accuracy/accuracy per atom will be written
-a, --atomic Test the accuracy of atomic label, i.e. energy / tensor (dipole, polar)
Run MD with LAMMPS
Running an MD simulation with LAMMPS is simpler. In the LAMMPS input file, one needs to specify the pair style as follows
pair_style deepmd graph.pb
pair_coeff * *
where graph.pb is the file name of the frozen model. It should be noted that LAMMPS counts atom types starting from 1, therefore, all LAMMPS atom types will be firstly subtracted by 1, and then passed into the DeePMD-kit engine to compute the interactions.
Installation
Easy install
There are various easy methods to install DeePMD-kit. Choose one that you prefer. If you want to build by yourself, jump to the next two sections.
After your easy installation, DeePMD-kit (dp) and LAMMPS (lmp) will be available to execute. You can try dp -h and lmp -h to see the help. mpirun is also available considering you may want to train models or run LAMMPS in parallel.
Note
Note: The off-line packages and conda packages require the GNU C Library 2.17 or above. The GPU version requires compatible NVIDIA driver to be installed in advance. It is possible to force conda to override detection when installation, but these requirements are still necessary during runtime.
Install off-line packages
Both CPU and GPU version offline packages are available in the Releases page.
Some packages are splited into two files due to size limit of GitHub. One may merge them into one after downloading:
cat deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh.0 deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh.1 > deepmd-kit-2.1.1-cuda11.6_gpu-Linux-x86_64.sh
One may enable the environment using
conda activate /path/to/deepmd-kit
Install with conda
DeePMD-kit is avaiable with conda. Install Anaconda or Miniconda first.
Offical channel
One may create an environment that contains the CPU version of DeePMD-kit and LAMMPS:
conda create -n deepmd deepmd-kit=*=*cpu libdeepmd=*=*cpu lammps -c https://conda.deepmodeling.com -c defaults
Or one may want to create a GPU environment containing CUDA Toolkit:
conda create -n deepmd deepmd-kit=*=*gpu libdeepmd=*=*gpu lammps cudatoolkit=11.6 horovod -c https://conda.deepmodeling.com -c defaults
One could change the CUDA Toolkit version from 10.2 or 11.6.
One may specify the DeePMD-kit version such as 2.1.1 using
conda create -n deepmd deepmd-kit=2.1.1=*cpu libdeepmd=2.1.1=*cpu lammps horovod -c https://conda.deepmodeling.com -c defaults
One may enable the environment using
conda activate deepmd
conda-forge channel
DeePMD-kit is also available on the conda-forge channel:
conda create -n deepmd deepmd-kit lammps -c conda-forge
The supported platform includes Linux x86-64, macOS x86-64, and macOS arm64. Read conda-forge FAQ to learn how to install CUDA-enabled packages.
Install with docker
A docker for installing the DeePMD-kit is available here.
To pull the CPU version:
docker pull ghcr.io/deepmodeling/deepmd-kit:2.1.1_cpu
To pull the GPU version:
docker pull ghcr.io/deepmodeling/deepmd-kit:2.1.1_cuda11.6_gpu
To pull the ROCm version:
docker pull deepmodeling/dpmdkit-rocm:dp2.0.3-rocm4.5.2-tf2.6-lmp29Sep2021
Install Python interface with pip
If you have no existing TensorFlow installed, you can use pip to install the pre-built package of the Python interface with CUDA 11 supported:
pip install deepmd-kit[gpu]
Or install the CPU version without CUDA supported:
pip install deepmd-kit[cpu]
LAMMPS module is only provided on Linux and macOS. To enable it, add lmp to extras:
pip install deepmd-kit[gpu,lmp]
MPICH is required for parallel running.
It is suggested to install the package into an isolated environment. The supported platform includes Linux x86-64 and aarch64 with GNU C Library 2.28 or above, macOS x86-64, and Windows x86-64. A specific version of TensorFlow which is compatible with DeePMD-kit will be also installed.
Warning
If your platform is not supported, or want to build against the installed TensorFlow, or want to enable ROCM support, please build from source.
Install from source code
Please follow our GitHub webpage to download the latest released version and development version.
Or get the DeePMD-kit source code by git clone
cd /some/workspace
git clone --recursive https://github.com/deepmodeling/deepmd-kit.git deepmd-kit
The --recursive option clones all submodules needed by DeePMD-kit.
For convenience, you may want to record the location of the source to a variable, saying deepmd_source_dir by
cd deepmd-kit
deepmd_source_dir=`pwd`
Install the python interface
Install Tensorflow’s python interface
First, check the python version on your machine
python --version
We follow the virtual environment approach to install TensorFlow’s Python interface. The full instruction can be found on the official TensorFlow website. TensorFlow 1.8 or later is supported. Now we assume that the Python interface will be installed to the virtual environment directory $tensorflow_venv
virtualenv -p python3 $tensorflow_venv
source $tensorflow_venv/bin/activate
pip install --upgrade pip
pip install --upgrade tensorflow
It is important that every time a new shell is started and one wants to use DeePMD-kit, the virtual environment should be activated by
source $tensorflow_venv/bin/activate
if one wants to skip out of the virtual environment, he/she can do
deactivate
If one has multiple python interpreters named something like python3.x, it can be specified by, for example
virtualenv -p python3.7 $tensorflow_venv
If one does not need the GPU support of DeePMD-kit and is concerned about package size, the CPU-only version of TensorFlow should be installed by
pip install --upgrade tensorflow-cpu
To verify the installation, run
python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
One should remember to activate the virtual environment every time he/she uses DeePMD-kit.
One can also build the TensorFlow Python interface from source for custom hardware optimization, such as CUDA, ROCM, or OneDNN support.
Install the DeePMD-kit’s python interface
Check the compiler version on your machine
gcc --version
The compiler GCC 4.8 or later is supported in the DeePMD-kit. Note that TensorFlow may have specific requirements for the compiler version. It is recommended to use the same compiler version as TensorFlow, which can be printed by python -c "import tensorflow;print(tensorflow.version.COMPILER_VERSION)".
Execute
cd $deepmd_source_dir
pip install .
One may set the following environment variables before executing pip:
Environment variables | Allowed value | Default value | Usage |
|---|---|---|---|
DP_VARIANT |
|
| Build CPU variant or GPU variant with CUDA or ROCM support. |
CUDA_TOOLKIT_ROOT_DIR | Path | Detected automatically | The path to the CUDA toolkit directory. CUDA 7.0 or later is supported. NVCC is required. |
ROCM_ROOT | Path | Detected automatically | The path to the ROCM toolkit directory. |
TENSORFLOW_ROOT | Path | Detected automatically | The path to TensorFlow Python library. By default the installer only finds TensorFlow under user site-package directory ( |
DP_ENABLE_NATIVE_OPTIMIZATION | 0, 1 | 0 | Enable compilation optimization for the native machine’s CPU type. Do not enable it if generated code will run on different CPUs. |
To test the installation, one should first jump out of the source directory
cd /some/other/workspace
then execute
dp -h
It will print the help information like
usage: dp [-h] {train,freeze,test} ...
DeePMD-kit: A deep learning package for many-body potential energy
representation and molecular dynamics
optional arguments:
-h, --help show this help message and exit
Valid subcommands:
{train,freeze,test}
train train a model
freeze freeze the model
test test the model
Install horovod and mpi4py
Horovod and mpi4py are used for parallel training. For better performance on GPU, please follow the tuning steps in Horovod on GPU.
# With GPU, prefer NCCL as a communicator.
HOROVOD_WITHOUT_GLOO=1 HOROVOD_WITH_TENSORFLOW=1 HOROVOD_GPU_OPERATIONS=NCCL HOROVOD_NCCL_HOME=/path/to/nccl pip install horovod mpi4py
If your work in a CPU environment, please prepare runtime as below:
# By default, MPI is used as communicator.
HOROVOD_WITHOUT_GLOO=1 HOROVOD_WITH_TENSORFLOW=1 pip install horovod mpi4py
To ensure Horovod has been built with proper framework support enabled, one can invoke the horovodrun --check-build command, e.g.,
$ horovodrun --check-build
Horovod v0.22.1:
Available Frameworks:
[X] TensorFlow
[X] PyTorch
[ ] MXNet
Available Controllers:
[X] MPI
[X] Gloo
Available Tensor Operations:
[X] NCCL
[ ] DDL
[ ] CCL
[X] MPI
[X] Gloo
From version 2.0.1, Horovod and mpi4py with MPICH support are shipped with the installer.
If you don’t install Horovod, DeePMD-kit will fall back to serial mode.
Install the C++ interface
If one does not need to use DeePMD-kit with Lammps or I-Pi, then the python interface installed in the previous section does everything and he/she can safely skip this section.
Install Tensorflow’s C++ interface
The C++ interface of DeePMD-kit was tested with compiler GCC >= 4.8. It is noticed that the I-Pi support is only compiled with GCC >= 4.8. Note that TensorFlow may have specific requirements for the compiler version.
First, the C++ interface of Tensorflow should be installed. It is noted that the version of Tensorflow should be consistent with the python interface. You may follow the instruction or run the script $deepmd_source_dir/source/install/build_tf.py to install the corresponding C++ interface.
Install DeePMD-kit’s C++ interface
Now go to the source code directory of DeePMD-kit and make a building place.
cd $deepmd_source_dir/source
mkdir build
cd build
I assume you want to install DeePMD-kit into path $deepmd_root, then execute CMake
cmake -DTENSORFLOW_ROOT=$tensorflow_root -DCMAKE_INSTALL_PREFIX=$deepmd_root ..
where the variable tensorflow_root stores the location where TensorFlow’s C++ interface is installed.
One may add the following arguments to cmake:
CMake Aurgements | Allowed value | Default value | Usage |
|---|---|---|---|
-DTENSORFLOW_ROOT=<value> | Path | - | The Path to TensorFlow’s C++ interface. |
-DCMAKE_INSTALL_PREFIX=<value> | Path | - | The Path where DeePMD-kit will be installed. |
-DUSE_CUDA_TOOLKIT=<value> |
|
| If |
-DCUDA_TOOLKIT_ROOT_DIR=<value> | Path | Detected automatically | The path to the CUDA toolkit directory. CUDA 7.0 or later is supported. NVCC is required. |
-DUSE_ROCM_TOOLKIT=<value> |
|
| If |
-DCMAKE_HIP_COMPILER_ROCM_ROOT=<value> | Path | Detected automatically | The path to the ROCM toolkit directory. |
-DLAMMPS_SOURCE_ROOT=<value> | Path | - | Only neccessary for LAMMPS plugin mode. The path to the LAMMPS source code. LAMMPS 8Apr2021 or later is supported. If not assigned, the plugin mode will not be enabled. |
-DUSE_TF_PYTHON_LIBS=<value> |
|
| If |
-DENABLE_NATIVE_OPTIMIZATION |
|
| Enable compilation optimization for the native machine’s CPU type. Do not enable it if generated code will run on different CPUs. |
If the CMake has been executed successfully, then run the following make commands to build the package:
make -j4
make install
Option -j4 means using 4 processes in parallel. You may want to use a different number according to your hardware.
If everything works fine, you will have the following executable and libraries installed in $deepmd_root/bin and $deepmd_root/lib
$ ls $deepmd_root/bin
dp_ipi dp_ipi_low
$ ls $deepmd_root/lib
libdeepmd_cc_low.so libdeepmd_ipi_low.so libdeepmd_lmp_low.so libdeepmd_low.so libdeepmd_op_cuda.so libdeepmd_op.so
libdeepmd_cc.so libdeepmd_ipi.so libdeepmd_lmp.so libdeepmd_op_cuda_low.so libdeepmd_op_low.so libdeepmd.so
Install LAMMPS
There are two ways to install LAMMPS: the built-in mode and the plugin mode. The built-in mode builds LAMMPS along with the DeePMD-kit and DeePMD-kit will be loaded automatically when running LAMMPS. The plugin mode builds LAMMPS and a plugin separately, so one needs to use plugin load command to load the DeePMD-kit’s LAMMPS plugin library.
Install LAMMPS’s DeePMD-kit module (built-in mode)
Before following this section, DeePMD-kit C++ interface should have be installed.
DeePMD-kit provides a module for running MD simulations with LAMMPS. Now make the DeePMD-kit module for LAMMPS.
cd $deepmd_source_dir/source/build
make lammps
DeePMD-kit will generate a module called USER-DEEPMD in the build directory. If you need the low-precision version, move env_low.sh to env.sh in the directory. Now download the LAMMPS code, and uncompress it.
cd /some/workspace
wget https://github.com/lammps/lammps/archive/stable_23Jun2022_update2.tar.gz
tar xf stable_23Jun2022_update2.tar.gz
The source code of LAMMPS is stored in the directory lammps-stable_23Jun2022_update2. Now go into the LAMMPS code and copy the DeePMD-kit module like this
cd lammps-stable_23Jun2022_update2/src/
cp -r $deepmd_source_dir/source/build/USER-DEEPMD .
make yes-kspace
make yes-extra-fix
make yes-user-deepmd
You can enable any other package you want. Now build LAMMPS
make mpi -j4
If everything works fine, you will end up with an executable lmp_mpi.
./lmp_mpi -h
The DeePMD-kit module can be removed from the LAMMPS source code by
make no-user-deepmd
Install LAMMPS (plugin mode)
Starting from 8Apr2021, LAMMPS also provides a plugin mode, allowing one to build LAMMPS and a plugin separately.
Now download the LAMMPS code (8Apr2021 or later), and uncompress it:
cd /some/workspace
wget https://github.com/lammps/lammps/archive/stable_23Jun2022_update2.tar.gz
tar xf stable_23Jun2022_update2.tar.gz
The source code of LAMMPS is stored in the directory lammps-stable_23Jun2022_update2. The directory of the source code should be specified as the CMAKE argument LAMMPS_SOURCE_ROOT during installation of the DeePMD-kit C++ interface. Now go into the LAMMPS directory and create a directory called build
mkdir -p lammps-stable_23Jun2022_update2/build/
cd lammps-stable_23Jun2022_update2/build/
Now build LAMMPS. Note that PLUGIN and KSPACE packages must be enabled, and BUILD_SHARED_LIBS must be set to yes. You can install any other package you want.
cmake -D PKG_PLUGIN=ON -D PKG_KSPACE=ON -D LAMMPS_INSTALL_RPATH=ON -D BUILD_SHARED_LIBS=yes -D CMAKE_INSTALL_PREFIX=${deepmd_root} -D CMAKE_INSTALL_LIBDIR=lib -D CMAKE_INSTALL_FULL_LIBDIR=${deepmd_root}/lib ../cmake
make -j4
make install
If everything works fine, you will end up with an executable ${deepmd_root}/bin/lmp.
${deepmd_root}/bin/lmp -h
Note
If ${tensorflow_root} or ${deepmd_root} is different from the prefix of LAMMPS, you need to append the library path to RUNPATH of liblammps.so. For example,
patchelf --set-rpath "${tensorflow_root}/lib" liblammps.so
Install i-PI
The i-PI works in a client-server model. The i-PI provides the server for integrating the replica positions of atoms, while the DeePMD-kit provides a client named dp_ipi that computes the interactions (including energy, forces and virials). The server and client communicate via the Unix domain socket or the Internet socket. Full documentation for i-PI can be found here. The source code and a complete installation guide for i-PI can be found here. To use i-PI with already existing drivers, install and update using Pip:
pip install -U i-PI
Test with Pytest:
pip install pytest
pytest --pyargs ipi.tests
Install GROMACS with DeepMD
Before following this section, DeePMD-kit C++ interface should have be installed.
Patch source code of GROMACS
Download the source code of a supported GROMACS version (2020.2) from https://manual.gromacs.org/2020.2/download.html. Run the following command:
export PATH=$PATH:$deepmd_kit_root/bin
dp_gmx_patch -d $gromacs_root -v $version -p
where deepmd_kit_root is the directory where the latest version of DeePMD-kit is installed, and gromacs_root refers to the source code directory of GROMACS. And version represents the version of GROMACS, where only 2020.2 is supported now. If attempting to patch another version of GROMACS you will still need to set version to 2020.2 as this is the only supported version, we cannot guarantee that patching other versions of GROMACS will work.
Compile GROMACS with deepmd-kit
The C++ interface of Deepmd-kit 2.x and TensorFlow 2.x are required. And be aware that only DeePMD-kit with high precision is supported now since we cannot ensure single precision is enough for a GROMACS simulation. Here is a sample compile script:
#!/bin/bash
export CC=/usr/bin/gcc
export CXX=/usr/bin/g++
export CMAKE_PREFIX_PATH="/path/to/fftw-3.3.9" # fftw libraries
mkdir build
cd build
cmake3 .. -DCMAKE_CXX_STANDARD=14 \ # not required, but c++14 seems to be more compatible with higher version of tensorflow
-DGMX_MPI=ON \
-DGMX_GPU=CUDA \ # Gromacs on ROCm has not been fully developed yet
-DCUDA_TOOLKIT_ROOT_DIR=/path/to/cuda \
-DCMAKE_INSTALL_PREFIX=/path/to/gromacs-2020.2-deepmd
make -j
make install
Building conda packages
One may want to keep both convenience and personalization of the DeePMD-kit. To achieve this goal, one can consider building conda packages. We provide building scripts in deepmd-kit-recipes organization. These building tools are driven by conda-build and conda-smithy.
For example, if one wants to turn on MPIIO package in LAMMPS, go to lammps-feedstock repository and modify recipe/build.sh. -D PKG_MPIIO=OFF should be changed to -D PKG_MPIIO=ON. Then go to the main directory and execute
./build-locally.py
This requires that Docker has been installed. After the building, the packages will be generated in build_artifacts/linux-64 and build_artifacts/noarch, and then one can install then executing
conda create -n deepmd lammps -c file:///path/to/build_artifacts -c https://conda.deepmodeling.com -c nvidia
One may also upload packages to one’s Anaconda channel, so they can be installed on other machines:
anaconda upload /path/to/build_artifacts/linux-64/*.tar.bz2 /path/to/build_artifacts/noarch/*.tar.bz2
Data
In this section, we will introduce how to convert the DFT-labeled data into the data format used by DeePMD-kit.
The DeePMD-kit organizes data in systems. Each system is composed of a number of frames. One may roughly view a frame as a snapshot of an MD trajectory, but it does not necessarily come from an MD simulation. A frame records the coordinates and types of atoms, cell vectors if the periodic boundary condition is assumed, energy, atomic forces and virials. It is noted that the frames in one system share the same number of atoms with the same type.
System
DeePMD-kit takes a system as the data structure. A snapshot of a system is called a frame. A system may contain multiple frames with the same atom types and numbers, i.e. the same formula (like H2O). To contains data with different formulas, one usually needs to divide data into multiple systems, which may sometimes result in sparse-frame systems. See a new system format to further combine different systems with the same atom numbers, when training with descriptor se_atten.
A system should contain system properties, input frame properties, and labeled frame properties. The system property contains the following property:
ID | Property | Raw file | Required/Optional | Shape | Description |
|---|---|---|---|---|---|
type | Atom type indexes | type.raw | Required | Natoms | Integers that start with 0 |
type_map | Atom type names | type_map.raw | Optional | Ntypes | Atom names that map to atom type, which is unnecessart to be contained in the periodic table |
nopbc | Non-periodic system | nopbc | Optional | 1 | If True, this system is non-periodic; otherwise it’s periodic |
The input frame properties contain the following property, the first axis of which is the number of frames:
ID | Property | Raw file | Unit | Required/Optional | Shape | Description |
|---|---|---|---|---|---|---|
coord | Atomic coordinates | coord.raw | Å | Required | Nframes * Natoms * 3 | |
box | Boxes | box.raw | Å | Required if periodic | Nframes * 3 * 3 | in the order |
fparam | Extra frame parameters | fparam.raw | Any | Optional | Nframes * Any | |
aparam | Extra atomic parameters | aparam.raw | Any | Optional | Nframes * aparam * Any |
The labeled frame properties is listed as follows, all of which will be used for training if and only if the loss function contains such property:
ID | Property | Raw file | Unit | Shape | Description |
|---|---|---|---|---|---|
energy | Frame energies | energy.raw | eV | Nframes | |
force | Atomic forces | force.raw | eV/Å | Nframes * Natoms * 3 | |
virial | Frame virial | virial.raw | eV | Nframes * 9 | in the order |
atom_ener | Atomic energies | atom_ener.raw | eV | Nframes * Natoms | |
atom_pref | Weights of atomic forces | atom_pref.raw | 1 | Nframes * Natoms | |
dipole | Frame dipole | dipole.raw | Any | Nframes * 3 | |
atomic_dipole | Atomic dipole | atomic_dipole.raw | Any | Nframes * Natoms * 3 | |
polarizability | Frame polarizability | polarizability.raw | Any | Nframes * 9 | in the order |
atomic_polarizability | Atomic polarizability | atomic_polarizability.raw | Any | Nframes * Natoms * 9 | in the order |
In general, we always use the following convention of units:
Property | Unit |
|---|---|
Time | ps |
Length | Å |
Energy | eV |
Force | eV/Å |
Virial | eV |
Pressure | Bar |
Formats of a system
Two binary formats, NumPy and HDF5, are supported for training. The raw format is not directly supported, but a tool is provided to convert data from the raw format to the NumPy format.
NumPy format
In a system with the Numpy format, the system properties are stored as text files ending with .raw, such as type.raw and type_map.raw, under the system directory. If one needs to train a non-periodic system, an empty nopbc file should be put under the system directory. Both input and labeled frame properties are saved as the NumPy binary data (NPY) files ending with .npy in each of the set.* directories. Take an example, a system may contain the following files:
type.raw
type_map.raw
nopbc
set.000/coord.npy
set.000/energy.npy
set.000/force.npy
set.001/coord.npy
set.001/energy.npy
set.001/force.npy
We assume that the atom types do not change in all frames. It is provided by type.raw, which has one line with the types of atoms written one by one. The atom types should be integers. For example the type.raw of a system that has 2 atoms with 0 and 1:
$ cat type.raw
0 1
Sometimes one needs to map the integer types to atom names. The mapping can be given by the file type_map.raw. For example
$ cat type_map.raw
O H
The type 0 is named by "O" and the type 1 is named by "H".
For training models with descriptor se_atten, a new system format is supported to put together the frame-sparse systems with the same atom number.
HDF5 format
A system with the HDF5 format has the same structure as the Numpy format, but in an HDF5 file, a system is organized as an HDF5 group. The file name of a Numpy file is the key in an HDF5 file, and the data is the value of the key. One needs to use # in a DP path to divide the path to the HDF5 file and the HDF5 path:
/path/to/data.hdf5#/H2O
Here, /path/to/data.hdf5 is the file path and /H2O is the HDF5 path. All HDF5 paths should start with /. There should be some data in the H2O group, such as /H2O/type.raw and /H2O/set.000/force.npy.
An HDF5 file with a large number of systems has better performance than multiple NumPy files in a large cluster.
Raw format and data conversion
A raw file is a plain text file with each information item written in one file and one frame written on one line. It’s not directly supported, but we provide a tool to convert them.
In the raw format, the property of one frame is provided per line, ending with .raw. Take an example, the default files that provide box, coordinate, force, energy and virial are box.raw, coord.raw, force.raw, energy.raw and virial.raw, respectively. Here is an example of force.raw:
$ cat force.raw
-0.724 2.039 -0.951 0.841 -0.464 0.363
6.737 1.554 -5.587 -2.803 0.062 2.222
-1.968 -0.163 1.020 -0.225 -0.789 0.343
This force.raw contains 3 frames with each frame having the forces of 2 atoms, thus it has 3 lines and 6 columns. Each line provides all the 3 force components of 2 atoms in 1 frame. The first three numbers are the 3 force components of the first atom, while the second three numbers are the 3 force components of the second atom. Other files are organized similarly. The number of lines of all raw files should be identical.
One can use the script $deepmd_source_dir/data/raw/raw_to_set.sh to convert the prepared raw files to the NumPy format. For example, if we have a raw file that contains 6000 frames,
$ ls
box.raw coord.raw energy.raw force.raw type.raw virial.raw
$ $deepmd_source_dir/data/raw/raw_to_set.sh 2000
nframe is 6000
nline per set is 2000
will make 3 sets
making set 0 ...
making set 1 ...
making set 2 ...
$ ls
box.raw coord.raw energy.raw force.raw set.000 set.001 set.002 type.raw virial.raw
It generates three sets set.000, set.001 and set.002, with each set containing 2000 frames in the Numpy format.
Prepare data with dpdata
One can use a convenient tool dpdata to convert data directly from the output of first principle packages to the DeePMD-kit format.
To install one can execute
pip install dpdata
An example of converting data VASP data in OUTCAR format to DeePMD-kit data can be found at
$deepmd_source_dir/examples/data_conv
Switch to that directory, then one can convert data by using the following python script
import dpdata
dsys = dpdata.LabeledSystem('OUTCAR')
dsys.to('deepmd/npy', 'deepmd_data', set_size = dsys.get_nframes())
get_nframes() method gets the number of frames in the OUTCAR, and the argument set_size enforces that the set size is equal to the number of frames in the system, viz. only one set is created in the system.
The data in DeePMD-kit format is stored in the folder deepmd_data.
A list of all supported data format and more nice features of dpdata can be found on the official website.
Model
Overall
A model has two parts, a descriptor that maps atomic configuration to a set of symmetry invariant features, and a fitting net that takes descriptor as input and predicts the atomic contribution to the target physical property. It’s defined in the model section of the input.json, for example,
"model": {
"type_map": ["O", "H"],
"descriptor" :{
"...": "..."
},
"fitting_net" : {
"...": "..."
}
}
The two subsections, descriptor and fitting_net, define the descriptor and the fitting net, respectively.
The type_map is optional, which provides the element names (but not necessarily same as the actual name of the element) of the corresponding atom types. A water model, as in this example, has two kinds of atoms. The atom types are internally recorded as integers, e.g., 0 for oxygen and 1 for hydrogen here. A mapping from the atom type to their names is provided by type_map.
DeePMD-kit implements the following descriptors:
se_e2_a: DeepPot-SE constructed from all information (both angular and radial) of atomic configurations. The embedding takes the distance between atoms as input.se_e2_r: DeepPot-SE constructed from radial information of atomic configurations. The embedding takes the distance between atoms as input.se_e3: DeepPot-SE constructed from all information (both angular and radial) of atomic configurations. The embedding takes angles between two neighboring atoms as input.loc_frame: Defines a local frame at each atom and compute the descriptor as local coordinates under this frame.hybrid: Concate a list of descriptors to form a new descriptor.
The fitting of the following physical properties is supported
Descriptor "se_e2_a"
The notation of se_e2_a is short for the Deep Potential Smooth Edition (DeepPot-SE) constructed from all information (both angular and radial) of atomic configurations. The e2 stands for the embedding with two-atoms information. This descriptor was described in detail in the DeepPot-SE paper.
Note that it is sometimes called a “two-atom embedding descriptor” which means the input of the embedding net is atomic distances. The descriptor does encode multi-body information (both angular and radial information of neighboring atoms).
In this example, we will train a DeepPot-SE model for a water system. A complete training input script of this example can be found in the directory.
$deepmd_source_dir/examples/water/se_e2_a/input.json
With the training input script, data are also provided in the example directory. One may train the model with the DeePMD-kit from the directory.
The construction of the descriptor is given by section descriptor. An example of the descriptor is provided as follows
"descriptor" :{
"type": "se_e2_a",
"rcut_smth": 0.50,
"rcut": 6.00,
"sel": [46, 92],
"neuron": [25, 50, 100],
"type_one_side": true,
"axis_neuron": 16,
"resnet_dt": false,
"seed": 1
}
The type of the descriptor is set to
"se_e2_a".rcut is the cut-off radius for neighbor searching, and the rcut_smth gives where the smoothing starts.
sel gives the maximum possible number of neighbors in the cut-off radius. It is a list, the length of which is the same as the number of atom types in the system, and
sel[i]denotes the maximum possible number of neighbors with typei.The neuron specifies the size of the embedding net. From left to right the members denote the sizes of each hidden layer from the input end to the output end, respectively. If the outer layer is twice the size of the inner layer, then the inner layer is copied and concatenated, then a ResNet architecture is built between them.
If the option type_one_side is set to
true, then the descriptor will consider the types of neighbor atoms. Otherwise, both the types of centric and neighbor atoms are considered.The axis_neuron specifies the size of the submatrix of the embedding matrix, the axis matrix as explained in the DeepPot-SE paper
If the option resnet_dt is set to
true, then a timestep is used in the ResNet.seed gives the random seed that is used to generate random numbers when initializing the model parameters.
Descriptor "se_e2_r"
The notation of se_e2_r is short for the Deep Potential Smooth Edition (DeepPot-SE) constructed from the radial information of atomic configurations. The e2 stands for the embedding with two-atom information.
A complete training input script of this example can be found in the directory
$deepmd_source_dir/examples/water/se_e2_r/input.json
The training input script is very similar to that of se_e2_a. The only difference lies in the descriptor section
"descriptor": {
"type": "se_e2_r",
"sel": [46, 92],
"rcut_smth": 0.50,
"rcut": 6.00,
"neuron": [5, 10, 20],
"resnet_dt": false,
"seed": 1,
"_comment": " that's all"
},
The type of the descriptor is set by the key type.
Descriptor "se_e3"
The notation of se_e3 is short for the Deep Potential Smooth Edition (DeepPot-SE) constructed from all information (both angular and radial) of atomic configurations. The embedding takes angles between two neighboring atoms as input (denoted by e3).
A complete training input script of this example can be found in the directory
$deepmd_source_dir/examples/water/se_e3/input.json
The training input script is very similar to that of se_e2_a. The only difference lies in the descriptor <model/descriptor> section
"descriptor": {
"type": "se_e3",
"sel": [40, 80],
"rcut_smth": 0.50,
"rcut": 6.00,
"neuron": [2, 4, 8],
"resnet_dt": false,
"seed": 1,
"_comment": " that's all"
},
The type of the descriptor is set by the key type.
Descriptor "se_atten"
DPA-1: Pretraining of Attention-based Deep Potential Model for Molecular Simulation
Here we propose DPA-1, a Deep Potential model with a novel attention mechanism, which is highly effective for representing the conformation and chemical spaces of atomic systems and learning the PES.
See this paper for more information. DPA-1 is implemented as a new descriptor "se_atten" for model training, which can be used after simply editing the input.json.
Installation
Follow the standard installation of Python interface in the DeePMD-kit. After that, you can smoothly use the DPA-1 model with the following instructions.
Introduction to new features of DPA-1
Next, we will list the detailed settings in input.json and the data format, especially for large systems with dozens of elements. An example of DPA-1 input can be found here.
Descriptor "se_atten"
The notation of se_atten is short for the smooth edition of Deep Potential with an attention mechanism. This descriptor was described in detail in the DPA-1 paper and the images above.
In this example, we will train a DPA-1 model for a water system. A complete training input script of this example can be found in the directory:
$deepmd_source_dir/examples/water/se_atten/input.json
With the training input script, data are also provided in the example directory. One may train the model with the DeePMD-kit from the directory.
An example of the DPA-1 descriptor is provided as follows
"descriptor" :{
"type": "se_atten",
"rcut_smth": 0.50,
"rcut": 6.00,
"sel": 120,
"neuron": [25, 50, 100],
"axis_neuron": 16,
"resnet_dt": false,
"attn": 128,
"attn_layer": 2,
"attn_mask": false,
"attn_dotr": true,
"seed": 1
}
The type of the descriptor is set to
"se_atten", which will use DPA-1 structures.rcut is the cut-off radius for neighbor searching, and the rcut_smth gives where the smoothing starts.
sel gives the maximum possible number of neighbors in the cut-off radius. It is an int. Note that this number highly affects the efficiency of training, which we usually use less than 200. (We use 120 for training 56 elements in OC2M dataset)
The neuron specifies the size of the embedding net. From left to right the members denote the sizes of each hidden layer from the input end to the output end, respectively. If the outer layer is twice the size of the inner layer, then the inner layer is copied and concatenated, then a ResNet architecture is built between them.
The axis_neuron specifies the size of the submatrix of the embedding matrix, the axis matrix as explained in the DeepPot-SE paper
If the option resnet_dt is set to
true, then a timestep is used in the ResNet.seed gives the random seed that is used to generate random numbers when initializing the model parameters.
attn sets the length of a hidden vector during scale-dot attention computation.
attn_layer sets the number of layers in attention mechanism.
attn_mask determines whether to mask the diagonal in the attention weights and False is recommended.
attn_dotr determines whether to dot the relative coordinates on the attention weights as a gated scheme, True is recommended.
Fitting "ener"
DPA-1 only supports "ener" fitting type, and you can refer here for detailed information.
Type embedding
DPA-1 only supports models with type embeddings. And the default setting is as follows:
"type_embedding":{
"neuron": [8],
"resnet_dt": false,
"seed": 1
}
You can add these settings in input.json if you want to change the default ones, see here for detailed information.
Type map
For training large systems, especially those with dozens of elements, the type determines the element index of training data:
"type_map": [
"Mg",
"Al",
"Cu"
]
which should include all the elements in the dataset you want to train on.
Data format
DPA-1 supports the standard data format, which is detailed in data-conv.md and system.md. Note that in this format, only those frames with the same fingerprint (i.e. the number of atoms of different elements) can be put together as a unified system. This may lead to sparse frame numbers in those rare systems.
An ideal way is to put systems with the same total number of atoms together, which is the way we trained DPA-1 on OC2M. This system format, which is called mixed_type, is proper to put frame-sparse systems together and is slightly different from the standard one. Take an example, a mixed_type may contain the following files:
type.raw
type_map.raw
set.000/box.npy
set.000/coord.npy
set.000/energy.npy
set.000/force.npy
set.000/real_atom_types.npy
This system contains Nframes frames with the same atom number Natoms, the total number of element types contained in all frames is Ntypes. Note that we put all the frames in one set set.000. Most files are the same as those in standard formats, here we only list the distinct ones:
ID | Property | File | Required/Optional | Shape | Description |
|---|---|---|---|---|---|
/ | Atom type indexes (place holder) | type.raw | Required | Natoms | All zeros to fake the type input |
type_map | Atom type names | type_map.raw | Required | Ntypes | Atom names that map to atom type contained in all the frames, which is unnecessart to be contained in the periodic table |
type | Atom type indexes of each frame | real_atom_types.npy | Required | Nframes * Natoms | Integers that describe atom types in each frame, corresponding to indexes in type_map |
With these edited files, one can put together frames with the same Natoms, instead of the same formula (like H2O). Note that this mixed_type format only supports se_atten descriptor.
The API to generate or transfer to mixed_type format will be uploaded on dpdata soon for a more convenient experience.
Training example
Here we upload the AlMgCu example shown in the paper, you can download it here: Baidu disk; Google disk.
Descriptor "hybrid"
This descriptor hybridizes multiple descriptors to form a new descriptor. For example, we have a list of descriptors denoted by \(\mathcal D_1\), \(\mathcal D_2\), …, \(\mathcal D_N\), the hybrid descriptor this the concatenation of the list, i.e. \(\mathcal D = (\mathcal D_1, \mathcal D_2, \cdots, \mathcal D_N)\).
To use the descriptor in DeePMD-kit, one firstly set the type to hybrid, then provide the definitions of the descriptors by the items in the list,
"descriptor" :{
"type": "hybrid",
"list" : [
{
"type" : "se_e2_a",
...
},
{
"type" : "se_e2_r",
...
}
]
},
A complete training input script of this example can be found in the directory
$deepmd_source_dir/examples/water/hybrid/input.json
Determine sel
All descriptors require to set sel, which means the expected maximum number of type-i neighbors of an atom. DeePMD-kit will allocate memory according to sel.
sel should not be too large or too small. If sel is too large, the computing will become much slower and cost more memory. If sel is not enough, the energy will be not conserved, making the accuracy of the model worse.
To determine a proper sel, one can calculate the neighbor stat of the training data before training:
dp neighbor-stat -s data -r 6.0 -t O H
where data is the directory of data, 6.0 is the cutoff radius, and O and H is the type map. The program will give the max_nbor_size. For example, max_nbor_size of the water example is [38, 72], meaning an atom may have 38 O neighbors and 72 H neighbors in the training data.
The sel should be set to a higher value than that of the training data, considering there may be some extreme geometries during MD simulations. As a result, we set sel to [46, 92] in the water example.
Fit energy
In this section, we will take $deepmd_source_dir/examples/water/se_e2_a/input.json as an example of the input file.
The fitting network
The construction of the fitting net is given by section fitting_net
"fitting_net" : {
"neuron": [240, 240, 240],
"resnet_dt": true,
"seed": 1
},
neuron specifies the size of the fitting net. If two neighboring layers are of the same size, then a ResNet architecture is built between them.
If the option resnet_dt is set to
true, then a timestep is used in the ResNet.seed gives the random seed that is used to generate random numbers when initializing the model parameters.
Loss
The loss function \(L\) for training energy is given by
where \(L_e\), \(L_f\), and \(L_v\) denote the loss in energy, forces and virials, respectively. \(p_e\), \(p_f\), and \(p_v\) give the prefactors of the energy, force and virial losses. The prefectors may not be a constant, rather it changes linearly with the learning rate. Taking the force prefactor for example, at training step \(t\), it is given by
where \(\alpha(t)\) denotes the learning rate at step \(t\). \(p_f^0\) and \(p_f^\infty\) specifies the \(p_f\) at the start of the training and the limit of \(t \to \infty\) (set by start_pref_f and limit_pref_f, respectively), i.e.
pref_f(t) = start_pref_f * ( lr(t) / start_lr ) + limit_pref_f * ( 1 - lr(t) / start_lr )
The loss section in the input.json is
"loss" : {
"start_pref_e": 0.02,
"limit_pref_e": 1,
"start_pref_f": 1000,
"limit_pref_f": 1,
"start_pref_v": 0,
"limit_pref_v": 0
}
The options start_pref_e, limit_pref_e, start_pref_f, limit_pref_f, start_pref_v and limit_pref_v determine the start and limit prefactors of energy, force and virial, respectively.
If one does not want to train with virial, then he/she may set the virial prefactors start_pref_v and limit_pref_v to 0.
Fit tensor like Dipole and Polarizability
Unlike energy, which is a scalar, one may want to fit some high dimensional physical quantity, like dipole (vector) and polarizability (matrix, shorted as polar). Deep Potential has provided different APIs to do this. In this example, we will show you how to train a model to fit a water system. A complete training input script of the examples can be found in
$deepmd_source_dir/examples/water_tensor/dipole/dipole_input.json
$deepmd_source_dir/examples/water_tensor/polar/polar_input.json
The training and validation data are also provided our examples. But note that the data provided along with the examples are of limited amount, and should not be used to train a production model.
Similar to the input.json used in ener mode, training JSON is also divided into model, learning_rate, loss and training. Most keywords remain the same as ener mode, and their meaning can be found here. To fit a tensor, one needs to modify model/fitting_net and loss.
The fitting Network
The fitting_net section tells DP which fitting net to use.
The JSON of dipole type should be provided like
"fitting_net" : {
"type": "dipole",
"sel_type": [0],
"neuron": [100,100,100],
"resnet_dt": true,
"seed": 1,
},
The JSON of polar type should be provided like
"fitting_net" : {
"type": "polar",
"sel_type": [0],
"neuron": [100,100,100],
"resnet_dt": true,
"seed": 1,
},
typespecifies which type of fitting net should be used. It should be eitherdipoleorpolar. Note thatglobal_polarmode in version 1.x is already deprecated and is merged intopolar. To specify whether a system is global or atomic, please see here.sel_typeis a list specifying which type of atoms have the quantity you want to fit. For example, in the water system,sel_typeis[0]since0represents atomO. If left unset, all types of atoms will be fitted.The rest arguments have the same meaning as they do in
enermode.
Loss
DP supports a combinational training of the global system (only a global tensor label, i.e. dipole or polar, is provided in a frame) and atomic system (labels for each atom included in sel_type are provided). In a global system, each frame has just one tensor label. For example, when fitting polar, each frame will just provide a 1 x 9 vector which gives the elements of the polarizability tensor of that frame in order XX, XY, XZ, YX, YY, YZ, XZ, ZY, ZZ. By contrast, in an atomic system, each atom in sel_type has a tensor label. For example, when fitting a dipole, each frame will provide a #sel_atom x 3 matrices, where #sel_atom is the number of atoms whose type are in sel_type.
The loss section tells DP the weight of these two kinds of loss, i.e.
loss = pref * global_loss + pref_atomic * atomic_loss
The loss section should be provided like
"loss" : {
"type": "tensor",
"pref": 1.0,
"pref_atomic": 1.0
},
type should be written as
tensoras a distinction fromenermode.pref and pref_atomic respectively specify the weight of global loss and atomic loss. It can not be left unset. If set to 0, the corresponding label will NOT be included in the training process.
Training Data Preparation
In tensor mode, the identification of the label’s type (global or atomic) is derived from the file name. The global label should be named dipole.npy/raw or polarizability.npy/raw, while the atomic label should be named atomic_dipole.npy/raw or atomic_polarizability.npy/raw. If wrongly named, DP will report an error
ValueError: cannot reshape array of size xxx into shape (xx,xx). This error may occur when your label mismatch it's name, i.e. you might store global tensor in `atomic_tensor.npy` or atomic tensor in `tensor.npy`.
In this case, please check the file name of the label.
Train the Model
The training command is the same as ener mode, i.e.
dp train input.json
The detailed loss can be found in lcurve.out:
# step rmse_val rmse_trn rmse_lc_val rmse_lc_trn rmse_gl_val rmse_gl_trn lr
0 8.34e+00 8.26e+00 8.34e+00 8.26e+00 0.00e+00 0.00e+00 1.0e-02
100 3.51e-02 8.55e-02 0.00e+00 8.55e-02 4.38e-03 0.00e+00 5.0e-03
200 4.77e-02 5.61e-02 0.00e+00 5.61e-02 5.96e-03 0.00e+00 2.5e-03
300 5.68e-02 1.47e-02 0.00e+00 0.00e+00 7.10e-03 1.84e-03 1.3e-03
400 3.73e-02 3.48e-02 1.99e-02 0.00e+00 2.18e-03 4.35e-03 6.3e-04
500 2.77e-02 5.82e-02 1.08e-02 5.82e-02 2.11e-03 0.00e+00 3.2e-04
600 2.81e-02 5.43e-02 2.01e-02 0.00e+00 1.01e-03 6.79e-03 1.6e-04
700 2.97e-02 3.28e-02 2.03e-02 0.00e+00 1.17e-03 4.10e-03 7.9e-05
800 2.25e-02 6.19e-02 9.05e-03 0.00e+00 1.68e-03 7.74e-03 4.0e-05
900 3.18e-02 5.54e-02 9.93e-03 5.54e-02 2.74e-03 0.00e+00 2.0e-05
1000 2.63e-02 5.02e-02 1.02e-02 5.02e-02 2.01e-03 0.00e+00 1.0e-05
1100 3.27e-02 5.89e-02 2.13e-02 5.89e-02 1.43e-03 0.00e+00 5.0e-06
1200 2.85e-02 2.42e-02 2.85e-02 0.00e+00 0.00e+00 3.02e-03 2.5e-06
1300 3.47e-02 5.71e-02 1.07e-02 5.71e-02 3.00e-03 0.00e+00 1.3e-06
1400 3.13e-02 5.76e-02 3.13e-02 5.76e-02 0.00e+00 0.00e+00 6.3e-07
1500 3.34e-02 1.11e-02 2.09e-02 0.00e+00 1.57e-03 1.39e-03 3.2e-07
1600 3.11e-02 5.64e-02 3.11e-02 5.64e-02 0.00e+00 0.00e+00 1.6e-07
1700 2.97e-02 5.05e-02 2.97e-02 5.05e-02 0.00e+00 0.00e+00 7.9e-08
1800 2.64e-02 7.70e-02 1.09e-02 0.00e+00 1.94e-03 9.62e-03 4.0e-08
1900 3.28e-02 2.56e-02 3.28e-02 0.00e+00 0.00e+00 3.20e-03 2.0e-08
2000 2.59e-02 5.71e-02 1.03e-02 5.71e-02 1.94e-03 0.00e+00 1.0e-08
One may notice that in each step, some of the local loss and global loss will be 0.0. This is because our training data and validation data consist of the global system and atomic system, i.e.
--training_data
>atomic_system
>global_system
--validation_data
>atomic_system
>global_system
During training, at each step when the lcurve.out is printed, the system used for evaluating the training (validation) error may be either with only global or only atomic labels, thus the corresponding atomic or global errors are missing and are printed as zeros.
Type embedding approach
We generate specific a type embedding vector for each atom type so that we can share one descriptor embedding net and one fitting net in total, which decline training complexity largely.
The training input script is similar to that of se_e2_a, but different by adding the type_embedding section.
Type embedding net
The model defines how the model is constructed, adding a section of type embedding net:
"model": {
"type_map": ["O", "H"],
"type_embedding":{
...
},
"descriptor" :{
...
},
"fitting_net" : {
...
}
}
The model will automatically apply the type embedding approach and generate type embedding vectors. If the type embedding vector is detected, the descriptor and fitting net would take it as a part of the input.
The construction of type embedding net is given by type_embedding. An example of type_embedding is provided as follows
"type_embedding":{
"neuron": [2, 4, 8],
"resnet_dt": false,
"seed": 1
}
The neuron specifies the size of the type embedding net. From left to right the members denote the sizes of each hidden layer from the input end to the output end, respectively. It takes a one-hot vector as input and output dimension equals to the last dimension of the neuron list. If the outer layer is twice the size of the inner layer, then the inner layer is copied and concatenated, then a ResNet architecture is built between them.
If the option resnet_dt is set to
true, then a timestep is used in the ResNet.seed gives the random seed that is used to generate random numbers when initializing the model parameters.
A complete training input script of this example can be found in the directory.
$deepmd_source_dir/examples/water/se_e2_a_tebd/input.json
See here for further explanation of type embedding.
Note
You can’t apply the compression method while using the atom type embedding.
Deep potential long-range (DPLR)
Notice: The interfaces of DPLR are not stable and subject to change
The method of DPLR is described in this paper. One is recommended to read the paper before using the DPLR.
In the following, we take the DPLR model for example to introduce the training and LAMMPS simulation with the DPLR model. The DPLR model is trained in two steps.
Train a deep Wannier model for Wannier centroids
We use the deep Wannier model (DW) to represent the relative position of the Wannier centroid (WC) with the atom with which it is associated. One may consult the introduction of the dipole model for a detailed introduction. An example input wc.json and a small dataset data for tutorial purposes can be found in
$deepmd_source_dir/examples/water/dplr/train/
It is noted that the tutorial dataset is not enough for training a productive model. Two settings make the training input script different from an energy training input:
"fitting_net": {
"type": "dipole",
"dipole_type": [0],
"neuron": [128, 128, 128],
"seed": 1
},
The type of fitting is set to dipole. The dipole is associated with type 0 atoms (oxygens), by the setting "dipole_type": [0]. What we trained is the displacement of the WC from the corresponding oxygen atom. It shares the same training input as the atomic dipole because both are 3-dimensional vectors defined on atoms. The loss section is provided as follows
"loss": {
"type": "tensor",
"pref": 0.0,
"pref_atomic": 1.0
},
so that the atomic dipole is trained as labels. Note that the NumPy compressed file atomic_dipole.npy should be provided in each dataset.
The training and freezing can be started from the example directory by
dp train dw.json && dp freeze -o dw.pb
Train the DPLR model
The training of the DPLR model is very similar to the standard short-range DP models. An example input script can be found in the example directory. The following section is introduced to compute the long-range energy contribution of the DPLR model, and modify the short-range DP model by this part.
"modifier": {
"type": "dipole_charge",
"model_name": "dw.pb",
"model_charge_map": [-8],
"sys_charge_map": [6, 1],
"ewald_h": 1.00,
"ewald_beta": 0.40
},
The model_name specifies which DW model is used to predict the position of WCs. model_charge_map gives the amount of charge assigned to WCs. sys_charge_map provides the nuclear charge of oxygen (type 0) and hydrogen (type 1) atoms. ewald_beta (unit \(\text{Å}^{-1}\)) gives the spread parameter controls the spread of Gaussian charges, and ewald_h (unit Å) assigns the grid size of Fourier transformation. The DPLR model can be trained and frozen by (from the example directory)
dp train ener.json && dp freeze -o ener.pb
Molecular dynamics simulation with DPLR
In MD simulations, the long-range part of the DPLR is calculated by the LAMMPS kspace support. Then the long-range interaction is back-propagated to atoms by DeePMD-kit. This setup is commonly used in classical molecular dynamics simulations as the “virtual site”. Unfortunately, LAMMPS does not natively support virtual sites, so we have to hack the LAMMPS code, which makes the input configuration and script a little wired.
An example of an input configuration file and script can be found in
$deepmd_source_dir/examples/water/dplr/lmp/
We use atom_style full for DPLR simulations. the coordinates of the WCs are explicitly written in the configuration file. Moreover, a virtual bond is established between the oxygens and the WCs to indicate they are associated together. The configuration file containing 128 H2O molecules is thus written as
512 atoms
3 atom types
128 bonds
1 bond types
0 16.421037674 xlo xhi
0 16.421037674 ylo yhi
0 16.421037674 zlo zhi
0 0 0 xy xz yz
Masses
1 16
2 2
3 16
Atoms
1 1 1 6 8.4960699081e+00 7.5073699951e+00 9.6371297836e+00
2 2 1 6 4.0597701073e+00 6.8156299591e+00 1.2051420212e+01
...
385 1 3 -8 8.4960699081e+00 7.5073699951e+00 9.6371297836e+00
386 2 3 -8 4.0597701073e+00 6.8156299591e+00 1.2051420212e+01
...
Bonds
1 1 1 385
2 1 2 386
...
The oxygens and hydrogens are assigned with atom types 1 and 2 (corresponding to training atom types 0 and 1), respectively. The WCs are assigned with atom type 3. We want to simulate heavy water so the mass of hydrogens is set to 2.
An example input script is provided in
$deepmd_source_dir/examples/water/dplr/lmp/in.lammps
Here are some explanations
# groups of real and virtual atoms
group real_atom type 1 2
group virtual_atom type 3
# bond between real and its corresponding virtual site should be given
# to setup a map between real and virtual atoms. However, no real
# bonded interaction is applied, thus bond_sytle "zero" is used.
pair_style deepmd ener.pb
pair_coeff * *
bond_style zero
bond_coeff *
special_bonds lj/coul 1 1 1 angle no
Type 1 and 2 (O and H) are real_atoms, while type 3 (WCs) are virtual_atoms. The model file ener.pb stores both the DW and DPLR models, so the position of WCs and the energy can be inferred from it. A virtual bond type is specified by bond_style zero. The special_bonds command switches off the exclusion of intramolecular interactions.
# kspace_style "pppm/dplr" should be used. in addition the
# gewald(1/distance) should be set the same as that used in
# training. Currently only ik differentiation is supported.
kspace_style pppm/dplr 1e-5
kspace_modify gewald ${BETA} diff ik mesh ${KMESH} ${KMESH} ${KMESH}
The long-range part is calculated by the kspace support of LAMMPS. The kspace_style pppm/dplr is required. The spread parameter set by variable BETA should be set the same as that used in training. The KMESH should be set dense enough so the long-range calculation is converged.
# "fix dplr" set the position of the virtual atom, and spread the
# electrostatic interaction asserting on the virtual atom to the real
# atoms. "type_associate" associates the real atom type its
# corresponding virtual atom type. "bond_type" gives the type of the
# bond between the real and virtual atoms.
fix 0 all dplr model ener.pb type_associate 1 3 bond_type 1
fix_modify 0 virial yes
The fix command dplr calculates the position of WCs by the DW model and back-propagates the long-range interaction on virtual atoms to real toms.
# compute the temperature of real atoms, excluding virtual atom contribution
compute real_temp real_atom temp
compute real_press all pressure real_temp
fix 1 real_atom nvt temp ${TEMP} ${TEMP} ${TAU_T}
fix_modify 1 temp real_temp
The temperature of the system should be computed from the real atoms. The kinetic contribution in the pressure tensor is also computed from the real atoms. The thermostat is applied to only real atoms. The computed temperature and pressure of real atoms can be accessed by, e.g.
fix thermo_print all print ${THERMO_FREQ} "$(step) $(pe) $(ke) $(etotal) $(enthalpy) $(c_real_temp) $(c_real_press) $(vol) $(c_real_press[1]) $(c_real_press[2]) $(c_real_press[3])" append thermo.out screen no title "# step pe ke etotal enthalpy temp press vol pxx pyy pzz"
The LAMMPS simulation can be started from the example directory by
lmp -i in.lammps
If LAMMPS complains that no model file ener.pb exists, it can be copied from the training example directory.
The MD simulation lasts for only 20 steps. If one runs a longer simulation, it will blow up, because the model is trained with a very limited dataset for very short training steps, thus is of poor quality.
Another restriction that should be noted is that the energies printed at the zero steps are not correct. This is because at the zero steps the position of the WC has not been updated with the DW model. The energies printed in later steps are correct.
Deep Potential - Range Correction (DPRc)
Deep Potential - Range Correction (DPRc) is designed to combine with QM/MM method, and corrects energies from a low-level QM/MM method to a high-level QM/MM method:
See the JCTC paper for details.
Training data
Instead the normal ab initio data, one needs to provide the correction from a low-level QM/MM method to a high-level QM/MM method:
Two levels of data use the same MM method, so \(E_\text{MM}\) is eliminated.
Training the DPRc model
In a DPRc model, QM atoms and MM atoms have different atom types. Assuming we have 4 QM atom types (C, H, O, P) and 2 MM atom types (HW, OW):
"type_map": ["C", "H", "HW", "O", "OW", "P"]
As described in the paper, the DPRc model only corrects \(E_\text{QM}\) and \(E_\text{QM/MM}\) within the cutoff, so we use a hybrid descriptor to describe them separatedly:
"descriptor" :{
"type": "hybrid",
"list" : [
{
"type": "se_e2_a",
"sel": [6, 11, 0, 6, 0, 1],
"rcut_smth": 1.00,
"rcut": 9.00,
"neuron": [12, 25, 50],
"exclude_types": [[2, 2], [2, 4], [4, 4], [0, 2], [0, 4], [1, 2], [1, 4], [3, 2], [3, 4], [5, 2], [5, 4]],
"axis_neuron": 12,
"set_davg_zero": true,
"_comment": " QM/QM interaction"
},
{
"type": "se_e2_a",
"sel": [6, 11, 100, 6, 50, 1],
"rcut_smth": 0.50,
"rcut": 6.00,
"neuron": [12, 25, 50],
"exclude_types": [[0, 0], [0, 1], [0, 3], [0, 5], [1, 1], [1, 3], [1, 5], [3, 3], [3, 5], [5, 5], [2, 2], [2, 4], [4, 4]],
"axis_neuron": 12,
"set_davg_zero": true,
"_comment": " QM/MM interaction"
}
]
}
exclude_types can be generated by the following Python script:
from itertools import combinations_with_replacement, product
qm = (0, 1, 3, 5)
mm = (2, 4)
print("QM/QM:", list(map(list, list(combinations_with_replacement(mm, 2)) + list(product(qm, mm)))))
print("QM/MM:", list(map(list, list(combinations_with_replacement(qm, 2)) + list(combinations_with_replacement(mm, 2)))))
Also, DPRc assumes MM atom energies (atom_ener) are zero:
"fitting_net": {
"neuron": [240, 240, 240],
"resnet_dt": true,
"atom_ener": [null, null, 0.0, null, 0.0, null]
}
Note that atom_ener only works when descriptor/set_davg_zero is true.
Run MD simulations
The DPRc model has the best practices with the AMBER QM/MM module. An example is given by GitLab RutgersLBSR/AmberDPRc. In theory, DPRc is able to be used with any QM/MM package, as long as the DeePMD-kit package accepts QM atoms and MM atoms within the cutoff range and returns energies and forces.
Training
Train a model
Several examples of training can be found in the examples directory:
$ cd $deepmd_source_dir/examples/water/se_e2_a/
After switching to that directory, the training can be invoked by
$ dp train input.json
where input.json is the name of the input script.
By default, the verbosity level of the DeePMD-kit is INFO, one may see a lot of important information on the code and environment showing on the screen. Among them two pieces of information regarding data systems are worth special notice.
DEEPMD INFO ---Summary of DataSystem: training -----------------------------------------------
DEEPMD INFO found 3 system(s):
DEEPMD INFO system natoms bch_sz n_bch prob pbc
DEEPMD INFO ../data_water/data_0/ 192 1 80 0.250 T
DEEPMD INFO ../data_water/data_1/ 192 1 160 0.500 T
DEEPMD INFO ../data_water/data_2/ 192 1 80 0.250 T
DEEPMD INFO --------------------------------------------------------------------------------------
DEEPMD INFO ---Summary of DataSystem: validation -----------------------------------------------
DEEPMD INFO found 1 system(s):
DEEPMD INFO system natoms bch_sz n_bch prob pbc
DEEPMD INFO ../data_water/data_3 192 1 80 1.000 T
DEEPMD INFO --------------------------------------------------------------------------------------
The DeePMD-kit prints detailed information on the training and validation data sets. The data sets are defined by training_data and validation_data defined in the training section of the input script. The training data set is composed of three data systems, while the validation data set is composed by one data system. The number of atoms, batch size, the number of batches in the system and the probability of using the system are all shown on the screen. The last column presents if the periodic boundary condition is assumed for the system.
During the training, the error of the model is tested every disp_freq training steps with the batch used to train the model and with numb_btch batches from the validating data. The training error and validation error are printed correspondingly in the file disp_file (default is lcurve.out). The batch size can be set in the input script by the key batch_size in the corresponding sections for the training and validation data set. An example of the output
# step rmse_val rmse_trn rmse_e_val rmse_e_trn rmse_f_val rmse_f_trn lr
0 3.33e+01 3.41e+01 1.03e+01 1.03e+01 8.39e-01 8.72e-01 1.0e-03
100 2.57e+01 2.56e+01 1.87e+00 1.88e+00 8.03e-01 8.02e-01 1.0e-03
200 2.45e+01 2.56e+01 2.26e-01 2.21e-01 7.73e-01 8.10e-01 1.0e-03
300 1.62e+01 1.66e+01 5.01e-02 4.46e-02 5.11e-01 5.26e-01 1.0e-03
400 1.36e+01 1.32e+01 1.07e-02 2.07e-03 4.29e-01 4.19e-01 1.0e-03
500 1.07e+01 1.05e+01 2.45e-03 4.11e-03 3.38e-01 3.31e-01 1.0e-03
The file contains 8 columns, from left to right, which are the training step, the validation loss, training loss, root mean square (RMS) validation error of energy, RMS training error of energy, RMS validation error of force, RMS training error of force and the learning rate. The RMS error (RMSE) of the energy is normalized by the number of atoms in the system. One can visualize this file with a simple Python script:
import numpy as np
import matplotlib.pyplot as plt
data = np.genfromtxt("lcurve.out", names=True)
for name in data.dtype.names[1:-1]:
plt.plot(data['step'], data[name], label=name)
plt.legend()
plt.xlabel('Step')
plt.ylabel('Loss')
plt.xscale('symlog')
plt.yscale('log')
plt.grid()
plt.show()
Checkpoints will be written to files with the prefix save_ckpt every save_freq training steps.
Warning
It is warned that the example water data (in folder examples/water/data) is of very limited amount, is provided only for testing purposes, and should not be used to train a production model.
Advanced options
In this section, we will take $deepmd_source_dir/examples/water/se_e2_a/input.json as an example of the input file.
Learning rate
The learning_rate section in input.json is given as follows
"learning_rate" :{
"type": "exp",
"start_lr": 0.001,
"stop_lr": 3.51e-8,
"decay_steps": 5000,
"_comment": "that's all"
}
start_lr gives the learning rate at the beginning of the training.
stop_lr gives the learning rate at the end of the training. It should be small enough to ensure that the network parameters satisfactorily converge.
During the training, the learning rate decays exponentially from start_lr to stop_lr following the formula:
where \(t\) is the training step, \(\alpha\) is the learning rate, \(\alpha_0\) is the starting learning rate (set by start_lr), \(\lambda\) is the decay rate, and \(\tau\) is the decay steps, i.e.
```
lr(t) = start_lr * decay_rate ^ ( t / decay_steps )
```
Training parameters
Other training parameters are given in the training section.
"training": {
"training_data": {
"systems": ["../data_water/data_0/", "../data_water/data_1/", "../data_water/data_2/"],
"batch_size": "auto"
},
"validation_data":{
"systems": ["../data_water/data_3"],
"batch_size": 1,
"numb_btch": 3
},
"mixed_precision": {
"output_prec": "float32",
"compute_prec": "float16"
},
"numb_steps": 1000000,
"seed": 1,
"disp_file": "lcurve.out",
"disp_freq": 100,
"save_freq": 1000
}
The sections training_data and validation_data give the training dataset and validation dataset, respectively. Taking the training dataset for example, the keys are explained below:
systems provide paths of the training data systems. DeePMD-kit allows you to provide multiple systems with different numbers of atoms. This key can be a
listor astr.At each training step, DeePMD-kit randomly picks batch_size frame(s) from one of the systems. The probability of using a system is by default in proportion to the number of batches in the system. More options are available for automatically determining the probability of using systems. One can set the key auto_prob to
"prob_uniform"all systems are used with the same probability."prob_sys_size"the probability of using a system is proportional to its size (number of frames)."prob_sys_size; sidx_0:eidx_0:w_0; sidx_1:eidx_1:w_1;..."thelistof systems is divided into blocks. Blockihas systems ranging fromsidx_itoeidx_i. The probability of using a system from blockiis proportional tow_i. Within one block, the probability of using a system is proportional to its size.
An example of using
"auto_prob"is given below. The probability of usingsystems[2]is 0.4, and the sum of the probabilities of usingsystems[0]andsystems[1]is 0.6. If the number of frames insystems[1]is twice ofsystem[0], then the probability of usingsystem[1]is 0.4 and that ofsystem[0]is 0.2.
"training_data": {
"systems": ["../data_water/data_0/", "../data_water/data_1/", "../data_water/data_2/"],
"auto_prob": "prob_sys_size; 0:2:0.6; 2:3:0.4",
"batch_size": "auto"
}
The probability of using systems can also be specified explicitly with key sys_probs which is a list having the length of the number of systems. For example
"training_data": {
"systems": ["../data_water/data_0/", "../data_water/data_1/", "../data_water/data_2/"],
"sys_probs": [0.5, 0.3, 0.2],
"batch_size": "auto:32"
}
The key batch_size specifies the number of frames used to train or validate the model in a training step. It can be set to
list: the length of which is the same as the systems. The batch size of each system is given by the elements of the list.int: all systems use the same batch size."auto": the same as"auto:32", see"auto:N""auto:N": automatically determines the batch size so that the batch_size times the number of atoms in the system is no less thanN.
The key numb_batch in validate_data gives the number of batches of model validation. Note that the batches may not be from the same system
The section mixed_precision specifies the mixed precision settings, which will enable the mixed precision training workflow for DeePMD-kit. The keys are explained below:
output_prec precision used in the output tensors, only
float32is supported currently.compute_prec precision used in the computing tensors, only
float16is supported currently. Note there are several limitations about mixed precision training:Only se_e2_a type descriptor is supported by the mixed precision training workflow.
The precision of the embedding net and the fitting net are forced to be set to
float32.
Other keys in the training section are explained below:
numb_steps The number of training steps.
seed The random seed for getting frames from the training data set.
disp_file The file for printing learning curve.
disp_freq The frequency of printing learning curve. Set in the unit of training steps
save_freq The frequency of saving checkpoint.
Options and environment variables
Several command line options can be passed to dp train, which can be checked with
$ dp train --help
An explanation will be provided
positional arguments:
INPUT the input json database
optional arguments:
-h, --help show this help message and exit
--init-model INIT_MODEL
Initialize a model by the provided checkpoint
--restart RESTART Restart the training from the provided checkpoint
--init-frz-model INIT_FRZ_MODEL
Initialize the training from the frozen model.
--skip-neighbor-stat Skip calculating neighbor statistics. Sel checking, automatic sel, and model compression will be disabled. (default: False)
--init-model model.ckpt, initializes the model training with an existing model that is stored in the checkpoint model.ckpt, the network architectures should match.
--restart model.ckpt, continues the training from the checkpoint model.ckpt.
--init-frz-model frozen_model.pb, initializes the training with an existing model that is stored in frozen_model.pb.
--skip-neighbor-stat will skip calculating neighbor statistics if one is concerned about performance. Some features will be disabled.
To maximize the performance, one should follow FAQ: How to control the parallelism of a job to control the number of threads.
One can set other environmental variables:
Environment variables | Allowed value | Default value | Usage |
|---|---|---|---|
DP_INTERFACE_PREC |
|
| Control high (double) or low (float) precision of training. |
DP_AUTO_PARALLELIZATION | 0, 1 | 0 | Enable auto parallelization for CPU operators. |
Adjust sel of a frozen model
One can use --init-frz-model features to adjust (increase or decrease) sel of a existing model. Firstly, one needs to adjust sel in input.json. For example, adjust from [46, 92] to [23, 46].
"model": {
"descriptor": {
"sel": [23, 46]
}
}
To obtain the new model at once, numb_steps should be set to zero:
"training": {
"numb_steps": 0
}
Then, one can initialize the training from the frozen model and freeze the new model at once:
dp train input.json --init-frz-model frozen_model.pb
dp freeze -o frozen_model_adjusted_sel.pb
Two models should give the same result when the input satisfies both constraints.
Note: At this time, this feature is only supported by se_e2_a descriptor with set_davg_true enabled, or hybrid composed of the above descriptors.
Training Parameters
Note
One can load, modify, and export the input file by using our effective web-based tool DP-GUI. All training parameters below can be set in DP-GUI. By clicking “SAVE JSON”, one can download the input file for furthur training.
- model:
- type:
dictargument path:model- type_map:
- type:
list, optionalargument path:model/type_mapA list of strings. Give the name to each type of atoms. It is noted that the number of atom type of training system must be less than 128 in a GPU environment.
- data_stat_nbatch:
- type:
int, optional, default:10argument path:model/data_stat_nbatchThe model determines the normalization from the statistics of the data. This key specifies the number of frames in each system used for statistics.
- data_stat_protect:
- type:
float, optional, default:0.01argument path:model/data_stat_protectProtect parameter for atomic energy regression.
- data_bias_nsample:
- type:
int, optional, default:10argument path:model/data_bias_nsampleThe number of training samples in a system to compute and change the energy bias.
- use_srtab:
- type:
str, optionalargument path:model/use_srtabThe table for the short-range pairwise interaction added on top of DP. 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.
- smin_alpha:
- type:
float, optionalargument path:model/smin_alphaThe short-range tabulated interaction will be swithed according to the distance of the nearest neighbor. This distance is calculated by softmin. This parameter is the decaying parameter in the softmin. It is only required when use_srtab is provided.
- sw_rmin:
- type:
float, optionalargument path:model/sw_rminThe lower boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
- sw_rmax:
- type:
float, optionalargument path:model/sw_rmaxThe upper boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
- type_embedding:
- type:
dict, optionalargument path:model/type_embeddingThe type embedding.
- neuron:
- type:
list, optional, default:[8]argument path:model/type_embedding/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/type_embedding/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/type_embedding/resnet_dtWhether to use a “Timestep” in the skip connection
- precision:
- type:
str, optional, default:defaultargument path:model/type_embedding/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/type_embedding/trainableIf the parameters in the embedding net are trainable
- seed:
- type:
NoneType|int, optional, default:Noneargument path:model/type_embedding/seedRandom seed for parameter initialization
- descriptor:
- type:
dictargument path:model/descriptorThe descriptor of atomic environment.
Depending on the value of type, different sub args are accepted.
- type:
- type:
str(flag key)argument path:model/descriptor/typeThe type of the descritpor. See explanation below.
loc_frame: Defines a local frame at each atom, and the compute the descriptor as local coordinates under this frame.
se_e2_a: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor.
se_e2_r: Used by the smooth edition of Deep Potential. Only the distance between atoms is used to construct the descriptor.
se_e3: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor. Three-body embedding will be used by this descriptor.
se_a_tpe: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor. Type embedding will be used by this descriptor.
se_atten: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor. Attention mechanism will be used by this descriptor.
hybrid: Concatenate of a list of descriptors as a new descriptor.
When type is set to
loc_frame:- sel_a:
- type:
listargument path:model/descriptor[loc_frame]/sel_aA list of integers. The length of the list should be the same as the number of atom types in the system. sel_a[i] gives the selected number of type-i neighbors. The full relative coordinates of the neighbors are used by the descriptor.
- sel_r:
- type:
listargument path:model/descriptor[loc_frame]/sel_rA list of integers. The length of the list should be the same as the number of atom types in the system. sel_r[i] gives the selected number of type-i neighbors. Only relative distance of the neighbors are used by the descriptor. sel_a[i] + sel_r[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[loc_frame]/rcutThe cut-off radius. The default value is 6.0
- axis_rule:
- type:
listargument path:model/descriptor[loc_frame]/axis_ruleA list of integers. The length should be 6 times of the number of types.
axis_rule[i*6+0]: class of the atom defining the first axis of type-i atom. 0 for neighbors with full coordinates and 1 for neighbors only with relative distance.
axis_rule[i*6+1]: type of the atom defining the first axis of type-i atom.
axis_rule[i*6+2]: index of the axis atom defining the first axis. Note that the neighbors with the same class and type are sorted according to their relative distance.
axis_rule[i*6+3]: class of the atom defining the second axis of type-i atom. 0 for neighbors with full coordinates and 1 for neighbors only with relative distance.
axis_rule[i*6+4]: type of the atom defining the second axis of type-i atom.
axis_rule[i*6+5]: index of the axis atom defining the second axis. Note that the neighbors with the same class and type are sorted according to their relative distance.
When type is set to
se_e2_a(or its aliasse_a):- sel:
- type:
str|list, optional, default:autoargument path:model/descriptor[se_e2_a]/selThis parameter set the number of selected neighbors for each type of atom. It can be:
List[int]. The length of the list should be the same as the number of atom types in the system. sel[i] gives the selected number of type-i neighbors. sel[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius. It is noted that the total sel value must be less than 4096 in a GPU environment.
str. Can be “auto:factor” or “auto”. “factor” is a float number larger than 1. This option will automatically determine the sel. In detail it counts the maximal number of neighbors with in the cutoff radius for each type of neighbor, then multiply the maximum by the “factor”. Finally the number is wraped up to 4 divisible. The option “auto” is equivalent to “auto:1.1”.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[se_e2_a]/rcutThe cut-off radius.
- rcut_smth:
- type:
float, optional, default:0.5argument path:model/descriptor[se_e2_a]/rcut_smthWhere to start smoothing. For example the 1/r term is smoothed from rcut to rcut_smth
- neuron:
- type:
list, optional, default:[10, 20, 40]argument path:model/descriptor[se_e2_a]/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- axis_neuron:
- type:
int, optional, default:4, alias: n_axis_neuronargument path:model/descriptor[se_e2_a]/axis_neuronSize of the submatrix of G (embedding matrix).
- activation_function:
- type:
str, optional, default:tanhargument path:model/descriptor[se_e2_a]/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_a]/resnet_dtWhether to use a “Timestep” in the skip connection
- type_one_side:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_a]/type_one_sideTry to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- precision:
- type:
str, optional, default:defaultargument path:model/descriptor[se_e2_a]/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_e2_a]/trainableIf the parameters in the embedding net is trainable
- seed:
- type:
NoneType|int, optionalargument path:model/descriptor[se_e2_a]/seedRandom seed for parameter initialization
- exclude_types:
- type:
list, optional, default:[]argument path:model/descriptor[se_e2_a]/exclude_typesThe excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
- set_davg_zero:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_a]/set_davg_zeroSet the normalization average to zero. This option should be set when atom_ener in the energy fitting is used
When type is set to
se_e3(or its aliasesse_at,se_a_3be,se_t):- sel:
- type:
str|list, optional, default:autoargument path:model/descriptor[se_e3]/selThis parameter set the number of selected neighbors for each type of atom. It can be:
List[int]. The length of the list should be the same as the number of atom types in the system. sel[i] gives the selected number of type-i neighbors. sel[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius. It is noted that the total sel value must be less than 4096 in a GPU environment.
str. Can be “auto:factor” or “auto”. “factor” is a float number larger than 1. This option will automatically determine the sel. In detail it counts the maximal number of neighbors with in the cutoff radius for each type of neighbor, then multiply the maximum by the “factor”. Finally the number is wraped up to 4 divisible. The option “auto” is equivalent to “auto:1.1”.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[se_e3]/rcutThe cut-off radius.
- rcut_smth:
- type:
float, optional, default:0.5argument path:model/descriptor[se_e3]/rcut_smthWhere to start smoothing. For example the 1/r term is smoothed from rcut to rcut_smth
- neuron:
- type:
list, optional, default:[10, 20, 40]argument path:model/descriptor[se_e3]/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/descriptor[se_e3]/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e3]/resnet_dtWhether to use a “Timestep” in the skip connection
- precision:
- type:
str, optional, default:defaultargument path:model/descriptor[se_e3]/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_e3]/trainableIf the parameters in the embedding net are trainable
- seed:
- type:
NoneType|int, optionalargument path:model/descriptor[se_e3]/seedRandom seed for parameter initialization
- set_davg_zero:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e3]/set_davg_zeroSet the normalization average to zero. This option should be set when atom_ener in the energy fitting is used
When type is set to
se_a_tpe(or its aliasse_a_ebd):- sel:
- type:
str|list, optional, default:autoargument path:model/descriptor[se_a_tpe]/selThis parameter set the number of selected neighbors for each type of atom. It can be:
List[int]. The length of the list should be the same as the number of atom types in the system. sel[i] gives the selected number of type-i neighbors. sel[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius. It is noted that the total sel value must be less than 4096 in a GPU environment.
str. Can be “auto:factor” or “auto”. “factor” is a float number larger than 1. This option will automatically determine the sel. In detail it counts the maximal number of neighbors with in the cutoff radius for each type of neighbor, then multiply the maximum by the “factor”. Finally the number is wraped up to 4 divisible. The option “auto” is equivalent to “auto:1.1”.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[se_a_tpe]/rcutThe cut-off radius.
- rcut_smth:
- type:
float, optional, default:0.5argument path:model/descriptor[se_a_tpe]/rcut_smthWhere to start smoothing. For example the 1/r term is smoothed from rcut to rcut_smth
- neuron:
- type:
list, optional, default:[10, 20, 40]argument path:model/descriptor[se_a_tpe]/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- axis_neuron:
- type:
int, optional, default:4, alias: n_axis_neuronargument path:model/descriptor[se_a_tpe]/axis_neuronSize of the submatrix of G (embedding matrix).
- activation_function:
- type:
str, optional, default:tanhargument path:model/descriptor[se_a_tpe]/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_a_tpe]/resnet_dtWhether to use a “Timestep” in the skip connection
- type_one_side:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_a_tpe]/type_one_sideTry to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- precision:
- type:
str, optional, default:defaultargument path:model/descriptor[se_a_tpe]/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_a_tpe]/trainableIf the parameters in the embedding net is trainable
- seed:
- type:
NoneType|int, optionalargument path:model/descriptor[se_a_tpe]/seedRandom seed for parameter initialization
- exclude_types:
- type:
list, optional, default:[]argument path:model/descriptor[se_a_tpe]/exclude_typesThe excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
- set_davg_zero:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_a_tpe]/set_davg_zeroSet the normalization average to zero. This option should be set when atom_ener in the energy fitting is used
- type_nchanl:
- type:
int, optional, default:4argument path:model/descriptor[se_a_tpe]/type_nchanlnumber of channels for type embedding
- type_nlayer:
- type:
int, optional, default:2argument path:model/descriptor[se_a_tpe]/type_nlayernumber of hidden layers of type embedding net
- numb_aparam:
- type:
int, optional, default:0argument path:model/descriptor[se_a_tpe]/numb_aparamdimension of atomic parameter. if set to a value > 0, the atomic parameters are embedded.
When type is set to
se_e2_r(or its aliasse_r):- sel:
- type:
str|list, optional, default:autoargument path:model/descriptor[se_e2_r]/selThis parameter set the number of selected neighbors for each type of atom. It can be:
List[int]. The length of the list should be the same as the number of atom types in the system. sel[i] gives the selected number of type-i neighbors. sel[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius. It is noted that the total sel value must be less than 4096 in a GPU environment.
str. Can be “auto:factor” or “auto”. “factor” is a float number larger than 1. This option will automatically determine the sel. In detail it counts the maximal number of neighbors with in the cutoff radius for each type of neighbor, then multiply the maximum by the “factor”. Finally the number is wraped up to 4 divisible. The option “auto” is equivalent to “auto:1.1”.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[se_e2_r]/rcutThe cut-off radius.
- rcut_smth:
- type:
float, optional, default:0.5argument path:model/descriptor[se_e2_r]/rcut_smthWhere to start smoothing. For example the 1/r term is smoothed from rcut to rcut_smth
- neuron:
- type:
list, optional, default:[10, 20, 40]argument path:model/descriptor[se_e2_r]/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/descriptor[se_e2_r]/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_r]/resnet_dtWhether to use a “Timestep” in the skip connection
- type_one_side:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_r]/type_one_sideTry to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- precision:
- type:
str, optional, default:defaultargument path:model/descriptor[se_e2_r]/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_e2_r]/trainableIf the parameters in the embedding net are trainable
- seed:
- type:
NoneType|int, optionalargument path:model/descriptor[se_e2_r]/seedRandom seed for parameter initialization
- exclude_types:
- type:
list, optional, default:[]argument path:model/descriptor[se_e2_r]/exclude_typesThe excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
- set_davg_zero:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_e2_r]/set_davg_zeroSet the normalization average to zero. This option should be set when atom_ener in the energy fitting is used
When type is set to
hybrid:- list:
- type:
listargument path:model/descriptor[hybrid]/listA list of descriptor definitions
When type is set to
se_atten:- sel:
- type:
list|str|int, optional, default:autoargument path:model/descriptor[se_atten]/selThis parameter set the number of selected neighbors. Note that this parameter is a little different from that in other descriptors. Instead of separating each type of atoms, only the summation matters. And this number is highly related with the efficiency, thus one should not make it too large. Usually 200 or less is enough, far away from the GPU limitation 4096. It can be:
int. The maximum number of neighbor atoms to be considered. We recommend it to be less than 200.
List[int]. The length of the list should be the same as the number of atom types in the system. sel[i] gives the selected number of type-i neighbors. Only the summation of sel[i] matters, and it is recommended to be less than 200. - str. Can be “auto:factor” or “auto”. “factor” is a float number larger than 1. This option will automatically determine the sel. In detail it counts the maximal number of neighbors with in the cutoff radius for each type of neighbor, then multiply the maximum by the “factor”. Finally the number is wraped up to 4 divisible. The option “auto” is equivalent to “auto:1.1”.
- rcut:
- type:
float, optional, default:6.0argument path:model/descriptor[se_atten]/rcutThe cut-off radius.
- rcut_smth:
- type:
float, optional, default:0.5argument path:model/descriptor[se_atten]/rcut_smthWhere to start smoothing. For example the 1/r term is smoothed from rcut to rcut_smth
- neuron:
- type:
list, optional, default:[10, 20, 40]argument path:model/descriptor[se_atten]/neuronNumber of neurons in each hidden layers of the embedding net. When two layers are of the same size or one layer is twice as large as the previous layer, a skip connection is built.
- axis_neuron:
- type:
int, optional, default:4, alias: n_axis_neuronargument path:model/descriptor[se_atten]/axis_neuronSize of the submatrix of G (embedding matrix).
- activation_function:
- type:
str, optional, default:tanhargument path:model/descriptor[se_atten]/activation_functionThe activation function in the embedding net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_atten]/resnet_dtWhether to use a “Timestep” in the skip connection
- type_one_side:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_atten]/type_one_sideWhether to consider the information from only one side or both sides.
- precision:
- type:
str, optional, default:defaultargument path:model/descriptor[se_atten]/precisionThe precision of the embedding net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- trainable:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_atten]/trainableIf the parameters in the embedding net is trainable
- seed:
- type:
NoneType|int, optionalargument path:model/descriptor[se_atten]/seedRandom seed for parameter initialization
- exclude_types:
- type:
list, optional, default:[]argument path:model/descriptor[se_atten]/exclude_typesThe excluded pairs of types which have no interaction with each other. For example, [[0, 1]] means no interaction between type 0 and type 1.
- set_davg_zero:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_atten]/set_davg_zeroSet the normalization average to zero. This option should be set when atom_ener in the energy fitting is used
- attn:
- type:
int, optional, default:128argument path:model/descriptor[se_atten]/attnThe length of hidden vectors in attention layers
- attn_layer:
- type:
int, optional, default:2argument path:model/descriptor[se_atten]/attn_layerThe number of attention layers
- attn_dotr:
- type:
bool, optional, default:Trueargument path:model/descriptor[se_atten]/attn_dotrWhether to do dot product with the normalized relative coordinates
- attn_mask:
- type:
bool, optional, default:Falseargument path:model/descriptor[se_atten]/attn_maskWhether to do mask on the diagonal in the attention matrix
- fitting_net:
- type:
dict, optionalargument path:model/fitting_netThe fitting of physical properties.
Depending on the value of type, different sub args are accepted.
- type:
- type:
str(flag key), default:enerargument path:model/fitting_net/typeThe type of the fitting. See explanation below.
ener: Fit an energy model (potential energy surface).
dipole: Fit an atomic dipole model. Global dipole labels or atomic dipole labels for all the selected atoms (see sel_type) should be provided by dipole.npy in each data system. The file either has number of frames lines and 3 times of number of selected atoms columns, or has number of frames lines and 3 columns. See loss parameter.
polar: Fit an atomic polarizability model. Global polarizazbility labels or atomic polarizability labels for all the selected atoms (see sel_type) should be provided by polarizability.npy in each data system. The file eith has number of frames lines and 9 times of number of selected atoms columns, or has number of frames lines and 9 columns. See loss parameter.
When type is set to
ener:- numb_fparam:
- type:
int, optional, default:0argument path:model/fitting_net[ener]/numb_fparamThe dimension of the frame parameter. If set to >0, file fparam.npy should be included to provided the input fparams.
- numb_aparam:
- type:
int, optional, default:0argument path:model/fitting_net[ener]/numb_aparamThe dimension of the atomic parameter. If set to >0, file aparam.npy should be included to provided the input aparams.
- neuron:
- type:
list, optional, default:[120, 120, 120], alias: n_neuronargument path:model/fitting_net[ener]/neuronThe number of neurons in each hidden layers of the fitting net. When two hidden layers are of the same size, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/fitting_net[ener]/activation_functionThe activation function in the fitting net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- precision:
- type:
str, optional, default:defaultargument path:model/fitting_net[ener]/precisionThe precision of the fitting net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- resnet_dt:
- type:
bool, optional, default:Trueargument path:model/fitting_net[ener]/resnet_dtWhether to use a “Timestep” in the skip connection
- trainable:
- type:
bool|list, optional, default:Trueargument path:model/fitting_net[ener]/trainableWhether the parameters in the fitting net are trainable. This option can be
bool: True if all parameters of the fitting net are trainable, False otherwise.
list of bool: Specifies if each layer is trainable. Since the fitting net is composed by hidden layers followed by a output layer, the length of tihs list should be equal to len(neuron)+1.
- rcond:
- type:
float, optional, default:0.001argument path:model/fitting_net[ener]/rcondThe condition number used to determine the inital energy shift for each type of atoms.
- seed:
- type:
NoneType|int, optionalargument path:model/fitting_net[ener]/seedRandom seed for parameter initialization of the fitting net
- atom_ener:
- type:
list, optional, default:[]argument path:model/fitting_net[ener]/atom_enerSpecify the atomic energy in vacuum for each type
When type is set to
dipole:- neuron:
- type:
list, optional, default:[120, 120, 120], alias: n_neuronargument path:model/fitting_net[dipole]/neuronThe number of neurons in each hidden layers of the fitting net. When two hidden layers are of the same size, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/fitting_net[dipole]/activation_functionThe activation function in the fitting net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Trueargument path:model/fitting_net[dipole]/resnet_dtWhether to use a “Timestep” in the skip connection
- precision:
- type:
str, optional, default:defaultargument path:model/fitting_net[dipole]/precisionThe precision of the fitting net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- sel_type:
- type:
int|NoneType|list, optional, alias: dipole_typeargument path:model/fitting_net[dipole]/sel_typeThe atom types for which the atomic dipole will be provided. If not set, all types will be selected.
- seed:
- type:
NoneType|int, optionalargument path:model/fitting_net[dipole]/seedRandom seed for parameter initialization of the fitting net
When type is set to
polar:- neuron:
- type:
list, optional, default:[120, 120, 120], alias: n_neuronargument path:model/fitting_net[polar]/neuronThe number of neurons in each hidden layers of the fitting net. When two hidden layers are of the same size, a skip connection is built.
- activation_function:
- type:
str, optional, default:tanhargument path:model/fitting_net[polar]/activation_functionThe activation function in the fitting net. Supported activation functions are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”. Note that “gelu” denotes the custom operator version, and “gelu_tf” denotes the TF standard version.
- resnet_dt:
- type:
bool, optional, default:Trueargument path:model/fitting_net[polar]/resnet_dtWhether to use a “Timestep” in the skip connection
- precision:
- type:
str, optional, default:defaultargument path:model/fitting_net[polar]/precisionThe precision of the fitting net parameters, supported options are “default”, “float16”, “float32”, “float64”, “bfloat16”. Default follows the interface precision.
- fit_diag:
- type:
bool, optional, default:Trueargument path:model/fitting_net[polar]/fit_diagFit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix.
- scale:
- type:
float|list, optional, default:1.0argument path:model/fitting_net[polar]/scaleThe output of the fitting net (polarizability matrix) will be scaled by
scale
- shift_diag:
- type:
bool, optional, default:Trueargument path:model/fitting_net[polar]/shift_diagWhether to shift the diagonal of polar, which is beneficial to training. Default is true.
- sel_type:
- type:
int|NoneType|list, optional, alias: pol_typeargument path:model/fitting_net[polar]/sel_typeThe atom types for which the atomic polarizability will be provided. If not set, all types will be selected.
- seed:
- type:
NoneType|int, optionalargument path:model/fitting_net[polar]/seedRandom seed for parameter initialization of the fitting net
- fitting_net_dict:
- type:
dict, optionalargument path:model/fitting_net_dictThe dictionary of multiple fitting nets in multi-task mode. Each fitting_net_dict[fitting_key] is the single definition of fitting of physical properties with user-defined name fitting_key.
- modifier:
- type:
dict, optionalargument path:model/modifierThe modifier of model output.
Depending on the value of type, different sub args are accepted.
- type:
The type of modifier. See explanation below.
-dipole_charge: Use WFCC to model the electronic structure of the system. Correct the long-range interaction
When type is set to
dipole_charge:- model_name:
- type:
strargument path:model/modifier[dipole_charge]/model_nameThe name of the frozen dipole model file.
- model_charge_map:
- type:
listargument path:model/modifier[dipole_charge]/model_charge_mapThe charge of the WFCC. The list length should be the same as the sel_type.
- sys_charge_map:
- type:
listargument path:model/modifier[dipole_charge]/sys_charge_mapThe charge of real atoms. The list length should be the same as the type_map
- ewald_beta:
- type:
float, optional, default:0.4argument path:model/modifier[dipole_charge]/ewald_betaThe splitting parameter of Ewald sum. Unit is A^-1
- ewald_h:
- type:
float, optional, default:1.0argument path:model/modifier[dipole_charge]/ewald_hThe grid spacing of the FFT grid. Unit is A
- compress:
- type:
dict, optionalargument path:model/compressModel compression configurations
Depending on the value of type, different sub args are accepted.
- type:
The type of model compression, which should be consistent with the descriptor type.
When type is set to
se_e2_a(or its aliasse_a):- model_file:
- type:
strargument path:model/compress[se_e2_a]/model_fileThe input model file, which will be compressed by the DeePMD-kit.
- table_config:
- type:
listargument path:model/compress[se_e2_a]/table_configThe arguments of model compression, including extrapolate(scale of model extrapolation), stride(uniform stride of tabulation’s first and second table), and frequency(frequency of tabulation overflow check).
- min_nbor_dist:
- type:
floatargument path:model/compress[se_e2_a]/min_nbor_distThe nearest distance between neighbor atoms saved in the frozen model.
- learning_rate:
- type:
dictargument path:learning_rateThe definitio of learning rate
- scale_by_worker:
- type:
str, optional, default:linearargument path:learning_rate/scale_by_workerWhen parallel training or batch size scaled, how to alter learning rate. Valid values are linear`(default), `sqrt or none.
Depending on the value of type, different sub args are accepted.
- type:
The type of the learning rate.
When type is set to
exp:- start_lr:
- type:
float, optional, default:0.001argument path:learning_rate[exp]/start_lrThe learning rate the start of the training.
- stop_lr:
- type:
float, optional, default:1e-08argument path:learning_rate[exp]/stop_lrThe desired learning rate at the end of the training.
- decay_steps:
- type:
int, optional, default:5000argument path:learning_rate[exp]/decay_stepsThe learning rate is decaying every this number of training steps.
- loss:
- type:
dict, optionalargument path:lossThe definition of loss function. The loss type should be set to tensor, ener or left unset.
Depending on the value of type, different sub args are accepted.
- type:
When type is set to
ener:- start_pref_e:
- type:
float|int, optional, default:0.02argument path:loss[ener]/start_pref_eThe prefactor of energy loss at the start of the training. Should be larger than or equal to 0. If set to none-zero value, the energy label should be provided by file energy.npy in each data system. If both start_pref_energy and limit_pref_energy are set to 0, then the energy will be ignored.
- limit_pref_e:
- type:
float|int, optional, default:1.0argument path:loss[ener]/limit_pref_eThe prefactor of energy loss at the limit of the training, Should be larger than or equal to 0. i.e. the training step goes to infinity.
- start_pref_f:
- type:
float|int, optional, default:1000argument path:loss[ener]/start_pref_fThe prefactor of force loss at the start of the training. Should be larger than or equal to 0. If set to none-zero value, the force label should be provided by file force.npy in each data system. If both start_pref_force and limit_pref_force are set to 0, then the force will be ignored.
- limit_pref_f:
- type:
float|int, optional, default:1.0argument path:loss[ener]/limit_pref_fThe prefactor of force loss at the limit of the training, Should be larger than or equal to 0. i.e. the training step goes to infinity.
- start_pref_v:
- type:
float|int, optional, default:0.0argument path:loss[ener]/start_pref_vThe prefactor of virial loss at the start of the training. Should be larger than or equal to 0. If set to none-zero value, the virial label should be provided by file virial.npy in each data system. If both start_pref_virial and limit_pref_virial are set to 0, then the virial will be ignored.
- limit_pref_v:
- type:
float|int, optional, default:0.0argument path:loss[ener]/limit_pref_vThe prefactor of virial loss at the limit of the training, Should be larger than or equal to 0. i.e. the training step goes to infinity.
- start_pref_ae:
- type:
float|int, optional, default:0.0argument path:loss[ener]/start_pref_aeThe prefactor of atom_ener loss at the start of the training. Should be larger than or equal to 0. If set to none-zero value, the atom_ener label should be provided by file atom_ener.npy in each data system. If both start_pref_atom_ener and limit_pref_atom_ener are set to 0, then the atom_ener will be ignored.
- limit_pref_ae:
- type:
float|int, optional, default:0.0argument path:loss[ener]/limit_pref_aeThe prefactor of atom_ener loss at the limit of the training, Should be larger than or equal to 0. i.e. the training step goes to infinity.
- start_pref_pf:
- type:
float|int, optional, default:0.0argument path:loss[ener]/start_pref_pfThe prefactor of atom_pref loss at the start of the training. Should be larger than or equal to 0. If set to none-zero value, the atom_pref label should be provided by file atom_pref.npy in each data system. If both start_pref_atom_pref and limit_pref_atom_pref are set to 0, then the atom_pref will be ignored.
- limit_pref_pf:
- type:
float|int, optional, default:0.0argument path:loss[ener]/limit_pref_pfThe prefactor of atom_pref loss at the limit of the training, Should be larger than or equal to 0. i.e. the training step goes to infinity.
- relative_f:
- type:
float|NoneType, optionalargument path:loss[ener]/relative_fIf provided, relative force error will be used in the loss. The difference of force will be normalized by the magnitude of the force in the label with a shift given by relative_f, i.e. DF_i / ( || F || + relative_f ) with DF denoting the difference between prediction and label and || F || denoting the L2 norm of the label.
- enable_atom_ener_coeff:
- type:
bool, optional, default:Falseargument path:loss[ener]/enable_atom_ener_coeffIf true, the energy will be computed as sum_i c_i E_i. c_i should be provided by file atom_ener_coeff.npy in each data system, otherwise it’s 1.
When type is set to
tensor:- pref:
- type:
float|intargument path:loss[tensor]/prefThe prefactor of the weight of global loss. It should be larger than or equal to 0. If controls the weight of loss corresponding to global label, i.e. ‘polarizability.npy` or dipole.npy, whose shape should be #frames x [9 or 3]. If it’s larger than 0.0, this npy should be included.
- pref_atomic:
- type:
float|intargument path:loss[tensor]/pref_atomicThe prefactor of the weight of atomic loss. It should be larger than or equal to 0. If controls the weight of loss corresponding to atomic label, i.e. atomic_polarizability.npy or atomic_dipole.npy, whose shape should be #frames x ([9 or 3] x #selected atoms). If it’s larger than 0.0, this npy should be included. Both pref and pref_atomic should be provided, and either can be set to 0.0.
- loss_dict:
- type:
dict, optionalargument path:loss_dictThe dictionary of definitions of multiple loss functions in multi-task mode. Each loss_dict[fitting_key], with user-defined name fitting_key in model/fitting_net_dict, is the single definition of loss function, whose type should be set to tensor, ener or left unset.
- training:
- type:
dictargument path:trainingThe training options.
- training_data:
- type:
dict, optionalargument path:training/training_dataConfigurations of training data.
- systems:
- type:
str|listargument path:training/training_data/systemsThe data systems for training. This key can be provided with a list that specifies the systems, or be provided with a string by which the prefix of all systems are given and the list of the systems is automatically generated.
- set_prefix:
- type:
str, optional, default:setargument path:training/training_data/set_prefixThe prefix of the sets in the systems.
- batch_size:
- type:
int|str|list, optional, default:autoargument path:training/training_data/batch_sizeThis key can be
list: the length of which is the same as the systems. The batch size of each system is given by the elements of the list.
int: all systems use the same batch size.
string “auto”: automatically determines the batch size so that the batch_size times the number of atoms in the system is no less than 32.
string “auto:N”: automatically determines the batch size so that the batch_size times the number of atoms in the system is no less than N.
- auto_prob:
- type:
str, optional, default:prob_sys_size, alias: auto_prob_styleargument path:training/training_data/auto_probDetermine the probability of systems automatically. The method is assigned by this key and can be
“prob_uniform” : the probability all the systems are equal, namely 1.0/self.get_nsystems()
“prob_sys_size” : the probability of a system is proportional to the number of batches in the system
“prob_sys_size;stt_idx:end_idx:weight;stt_idx:end_idx:weight;…” : the list of systems is devided into blocks. A block is specified by stt_idx:end_idx:weight, where stt_idx is the starting index of the system, end_idx is then ending (not including) index of the system, the probabilities of the systems in this block sums up to weight, and the relatively probabilities within this block is proportional to the number of batches in the system.
- sys_probs:
- type:
NoneType|list, optional, default:None, alias: sys_weightsargument path:training/training_data/sys_probsA list of float if specified. Should be of the same length as systems, specifying the probability of each system.
- validation_data:
- type:
dict|NoneType, optional, default:Noneargument path:training/validation_dataConfigurations of validation data. Similar to that of training data, except that a numb_btch argument may be configured
- systems:
- type:
str|listargument path:training/validation_data/systemsThe data systems for validation. This key can be provided with a list that specifies the systems, or be provided with a string by which the prefix of all systems are given and the list of the systems is automatically generated.
- set_prefix:
- type:
str, optional, default:setargument path:training/validation_data/set_prefixThe prefix of the sets in the systems.
- batch_size:
- type:
int|str|list, optional, default:autoargument path:training/validation_data/batch_sizeThis key can be
list: the length of which is the same as the systems. The batch size of each system is given by the elements of the list.
int: all systems use the same batch size.
string “auto”: automatically determines the batch size so that the batch_size times the number of atoms in the system is no less than 32.
string “auto:N”: automatically determines the batch size so that the batch_size times the number of atoms in the system is no less than N.
- auto_prob:
- type:
str, optional, default:prob_sys_size, alias: auto_prob_styleargument path:training/validation_data/auto_probDetermine the probability of systems automatically. The method is assigned by this key and can be
“prob_uniform” : the probability all the systems are equal, namely 1.0/self.get_nsystems()
“prob_sys_size” : the probability of a system is proportional to the number of batches in the system
“prob_sys_size;stt_idx:end_idx:weight;stt_idx:end_idx:weight;…” : the list of systems is devided into blocks. A block is specified by stt_idx:end_idx:weight, where stt_idx is the starting index of the system, end_idx is then ending (not including) index of the system, the probabilities of the systems in this block sums up to weight, and the relatively probabilities within this block is proportional to the number of batches in the system.
- sys_probs:
- type:
NoneType|list, optional, default:None, alias: sys_weightsargument path:training/validation_data/sys_probsA list of float if specified. Should be of the same length as systems, specifying the probability of each system.
- numb_btch:
- type:
int, optional, default:1, alias: numb_batchargument path:training/validation_data/numb_btchAn integer that specifies the number of systems to be sampled for each validation period.
- mixed_precision:
- type:
dict, optionalargument path:training/mixed_precisionConfigurations of mixed precision.
- output_prec:
- type:
str, optional, default:float32argument path:training/mixed_precision/output_precThe precision for mixed precision params. ” “The trainable variables precision during the mixed precision training process, ” “supported options are float32 only currently.
- compute_prec:
- type:
strargument path:training/mixed_precision/compute_precThe precision for mixed precision compute. ” “The compute precision during the mixed precision training process, “” “supported options are float16 and bfloat16 currently.
- numb_steps:
- type:
int, alias: stop_batchargument path:training/numb_stepsNumber of training batch. Each training uses one batch of data.
- seed:
- type:
NoneType|int, optionalargument path:training/seedThe random seed for getting frames from the training data set.
- disp_file:
- type:
str, optional, default:lcurve.outargument path:training/disp_fileThe file for printing learning curve.
- disp_freq:
- type:
int, optional, default:1000argument path:training/disp_freqThe frequency of printing learning curve.
- save_freq:
- type:
int, optional, default:1000argument path:training/save_freqThe frequency of saving check point.
- save_ckpt:
- type:
str, optional, default:model.ckptargument path:training/save_ckptThe file name of saving check point.
- disp_training:
- type:
bool, optional, default:Trueargument path:training/disp_trainingDisplaying verbose information during training.
- time_training:
- type:
bool, optional, default:Trueargument path:training/time_trainingTiming durining training.
- profiling:
- type:
bool, optional, default:Falseargument path:training/profilingProfiling during training.
- profiling_file:
- type:
str, optional, default:timeline.jsonargument path:training/profiling_fileOutput file for profiling.
- enable_profiler:
- type:
bool, optional, default:Falseargument path:training/enable_profilerEnable TensorFlow Profiler (available in TensorFlow 2.3) to analyze performance. The log will be saved to tensorboard_log_dir.
- tensorboard:
- type:
bool, optional, default:Falseargument path:training/tensorboardEnable tensorboard
- tensorboard_log_dir:
- type:
str, optional, default:logargument path:training/tensorboard_log_dirThe log directory of tensorboard outputs
- tensorboard_freq:
- type:
int, optional, default:1argument path:training/tensorboard_freqThe frequency of writing tensorboard events.
- data_dict:
- type:
dict, optionalargument path:training/data_dictThe dictionary of multi DataSystems in multi-task mode. Each data_dict[fitting_key], with user-defined name fitting_key in model/fitting_net_dict, contains training data and optional validation data definitions.
- fitting_weight:
- type:
dict, optionalargument path:training/fitting_weightEach fitting_weight[fitting_key], with user-defined name fitting_key in model/fitting_net_dict, is the training weight of fitting net fitting_key. Fitting nets with higher weights will be selected with higher probabilities to be trained in one step. Weights will be normalized and minus ones will be ignored. If not set, each fitting net will be equally selected when training.
- nvnmd:
- type:
dict, optionalargument path:nvnmdThe nvnmd options.
- net_size:
- type:
intargument path:nvnmd/net_sizeconfiguration the number of nodes of fitting_net, just can be set as 128
- map_file:
- type:
strargument path:nvnmd/map_fileA file containing the mapping tables to replace the calculation of embedding nets
- config_file:
- type:
strargument path:nvnmd/config_fileA file containing the parameters about how to implement the model in certain hardware
- weight_file:
- type:
strargument path:nvnmd/weight_filea *.npy file containing the weights of the model
- enable:
- type:
boolargument path:nvnmd/enableenable the nvnmd training
- restore_descriptor:
- type:
boolargument path:nvnmd/restore_descriptorenable to restore the parameter of embedding_net from weight.npy
- restore_fitting_net:
- type:
boolargument path:nvnmd/restore_fitting_netenable to restore the parameter of fitting_net from weight.npy
- quantize_descriptor:
- type:
boolargument path:nvnmd/quantize_descriptorenable the quantizatioin of descriptor
- quantize_fitting_net:
- type:
boolargument path:nvnmd/quantize_fitting_netenable the quantizatioin of fitting_net
Parallel training
Currently, parallel training is enabled in a synchronized way with help of Horovod. Depending on the number of training processes (according to MPI context) and the number of GPU cards available, DeePMD-kit will decide whether to launch the training in parallel (distributed) mode or in serial mode. Therefore, no additional options are specified in your JSON/YAML input file.
Tuning learning rate
Horovod works in the data-parallel mode, resulting in a larger global batch size. For example, the real batch size is 8 when batch_size is set to 2 in the input file and you launch 4 workers. Thus, learning_rate is automatically scaled by the number of workers for better convergence. Technical details of such heuristic rule are discussed at Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour.
The number of decay steps required to achieve the same accuracy can decrease by the number of cards (e.g., 1/2 of steps in the above case), but needs to be scaled manually in the input file.
In some cases, it won’t work well when scaling the learning rate by worker count in a linear way. Then you can try sqrt or none by setting argument scale_by_worker like below.
"learning_rate" :{
"scale_by_worker": "none",
"type": "exp"
}
Scaling test
Testing examples/water/se_e2_a on an 8-GPU host, linear acceleration can be observed with the increasing number of cards.
Num of GPU cards | Seconds every 100 samples | Samples per second | Speed up |
|---|---|---|---|
1 | 1.4515 | 68.89 | 1.00 |
2 | 1.5962 | 62.65*2 | 1.82 |
4 | 1.7635 | 56.71*4 | 3.29 |
8 | 1.7267 | 57.91*8 | 6.72 |
How to use
Training workers can be launched with horovodrun. The following command launches 4 processes on the same host:
CUDA_VISIBLE_DEVICES=4,5,6,7 horovodrun -np 4 \
dp train --mpi-log=workers input.json
Need to mention, the environment variable `CUDA_VISIBLE_DEVICES`` must be set to control parallelism on the occupied host where one process is bound to one GPU card.
To maximize the performance, one should follow FAQ: How to control the parallelism of a job to control the number of threads.
When using MPI with Horovod, horovodrun is a simple wrapper around mpirun. In the case where fine-grained control over options is passed to mpirun, mpirun can be invoked directly, and it will be detected automatically by Horovod, e.g.,
CUDA_VISIBLE_DEVICES=4,5,6,7 mpirun -l -launcher=fork -hosts=localhost -np 4 \
dp train --mpi-log=workers input.json
this is sometimes necessary for an HPC environment.
Whether distributed workers are initiated can be observed in the “Summary of the training” section in the log (world size > 1, and distributed).
[0] DEEPMD INFO ---Summary of the training---------------------------------------
[0] DEEPMD INFO distributed
[0] DEEPMD INFO world size: 4
[0] DEEPMD INFO my rank: 0
[0] DEEPMD INFO node list: ['exp-13-57']
[0] DEEPMD INFO running on: exp-13-57
[0] DEEPMD INFO computing device: gpu:0
[0] DEEPMD INFO CUDA_VISIBLE_DEVICES: 0,1,2,3
[0] DEEPMD INFO Count of visible GPU: 4
[0] DEEPMD INFO num_intra_threads: 0
[0] DEEPMD INFO num_inter_threads: 0
[0] DEEPMD INFO -----------------------------------------------------------------
Logging
What’s more, 2 command-line arguments are defined to control the logging behavior when performing parallel training with MPI.
optional arguments:
-l LOG_PATH, --log-path LOG_PATH
set log file to log messages to disk, if not
specified, the logs will only be output to console
(default: None)
-m {master,collect,workers}, --mpi-log {master,collect,workers}
Set the manner of logging when running with MPI.
'master' logs only on main process, 'collect'
broadcasts logs from workers to master and 'workers'
means each process will output its own log (default:
master)
Multi-task training
Training on multiple data sets (each data set contains several data systems) can be performed in multi-task mode, with one common descriptor and multiple specific fitting nets for each data set. One can simply switch the following parameters in training input script to perform multi-task mode:
fitting_net –> fitting_net_dict, each key of which can be one individual fitting net.
training_data, validation_data –> data_dict, each key of which can be one individual data set contains several data systems for corresponding fitting net, the keys must be consistent with those in fitting_net_dict.
loss –> loss_dict, each key of which can be one individual loss setting for corresponding fitting net, the keys must be consistent with those in fitting_net_dict, if not set, the corresponding fitting net will use the default loss.
(Optional) fitting_weight, each key of which can be a non-negative integer or float, deciding the chosen probability for corresponding fitting net in training, if not set or invalid, the corresponding fitting net will not be used.
The training procedure will automatically choose single-task or multi-task mode, based on the above parameters. Note that parameters of single-task mode and multi-task mode can not be mixed.
The supported descriptors for multi-task mode are listed:
The supported fitting nets for multi-task mode are listed:
The output of dp freeze command in multi-task mode can be seen in freeze command.
TensorBoard Usage
TensorBoard provides the visualization and tooling needed for machine learning experimentation. Full instructions for TensorBoard can be found here.
Highlighted features
DeePMD-kit can now use most of the interesting features enabled by TensorBoard!
Tracking and visualizing metrics, such as l2_loss, l2_energy_loss and l2_force_loss
Visualizing the model graph (ops and layers)
Viewing histograms of weights, biases, or other tensors as they change over time.
Viewing summaries of trainable variables
How to use Tensorboard with DeePMD-kit
Before running TensorBoard, make sure you have generated summary data in a log directory by modifying the input script, setting tensorboard to true in the training subsection will enable the TensorBoard data analysis. eg. water_se_a.json.
"training" : {
"systems": ["../data/"],
"set_prefix": "set",
"stop_batch": 1000000,
"batch_size": 1,
"seed": 1,
"_comment": " display and restart",
"_comment": " frequencies counted in batch",
"disp_file": "lcurve.out",
"disp_freq": 100,
"numb_test": 10,
"save_freq": 1000,
"save_ckpt": "model.ckpt",
"disp_training":true,
"time_training":true,
"tensorboard": true,
"tensorboard_log_dir":"log",
"tensorboard_freq": 1000,
"profiling": false,
"profiling_file":"timeline.json",
"_comment": "that's all"
}
Once you have event files, run TensorBoard and provide the log directory. This should print that TensorBoard has started. Next, connect to http://tensorboard_server_ip:6006.
TensorBoard requires a logdir to read logs from. For info on configuring TensorBoard, run TensorBoard –help. One can easily change the log name with “tensorboard_log_dir” and the sampling frequency with “tensorboard_freq”.
tensorboard --logdir path/to/logs
Examples
Tracking and visualizing loss metrics(red:train, blue:test)
Visualizing DeePMD-kit model graph
Viewing histograms of weights, biases, or other tensors as they change over time
Viewing summaries of trainable variables
Attention
Allowing the tensorboard analysis will takes extra execution time.(eg, 15% increasing @Nvidia GTX 1080Ti double precision with default water sample)
TensorBoard can be used in Google Chrome or Firefox. Other browsers might work, but there may be bugs or performance issues.
Known limitations of using GPUs
If you use DeePMD-kit in a GPU environment, the acceptable value range of some variables is additionally restricted compared to the CPU environment due to the software’s GPU implementations:
The number of atom types of a given system must be less than 128.
The maximum distance between an atom and its neighbors must be less than 128. It can be controlled by setting the rcut value of training parameters.
Theoretically, the maximum number of atoms that a single GPU can accept is about 10,000,000. However, this value is limited by the GPU memory size currently, usually within 1000,000 atoms even in the model compression mode.
The total sel value of training parameters(in
model/descriptorsection) must be less than 4096.The size of the last layer of the embedding net must be less than 1024 during the model compression process.
Finetune the pretrained model
Pretraining-and-finetuning is a widely used approach in other fields such as Computer Vision (CV) or Natural Language Processing (NLP) to vastly reduce the training cost, while it’s not trivial in potential models. Compositions and configurations of data samples or even computational parameters in upstream software (such as VASP) may be different between the pretrained and target datasets, leading to energy shifts or other diversities of training data.
Recently the emerging of methods such as DPA-1 has brought us to a new stage where we can perform similar pretraining-finetuning approaches. DPA-1 can hopefully learn the common knowledge in the pretrained dataset (especially the force information) and thus reduce the computational cost in downstream training tasks. If you have a pretrained model pretrained.pb (here we support models using se_atten descriptor and ener fitting net) on a large dataset (for example, OC2M in DPA-1 paper), a finetuning strategy can be performed by simply running:
$ dp train input.json --finetune pretrained.pb
The command above will change the energy bias in the last layer of the fitting net in pretrained.pb, according to the training dataset in input.json.
Warning
Note that the elements in the training dataset must be contained in the pretrained dataset.
The finetune procedure will inherit the model structures in pretrained.pb, and thus it will ignore the model parameters in input.json, such as descriptor, fitting_net, type_embedding and type_map. However, you can still set the trainable parameters in each part of input.json to control the training procedure.
To obtain a more simplified script, for example, you can change the model part in input.json to perform finetuning:
"model": {
"type_map": ["O", "H"],
"type_embedding": {"trainable": true},
"descriptor" : {},
"fitting_net" : {}
}
Freeze and Compress
Freeze a model
The trained neural network is extracted from a checkpoint and dumped into a protobuf(.pb) file. This process is called “freezing” a model. The idea and part of our code are from Morgan. To freeze a model, typically one does
$ dp freeze -o graph.pb
in the folder where the model is trained. The output model is called graph.pb.
In multi-task mode, this process will output several models, each of which contains the common descriptor and one of the user-defined fitting nets in fitting_net_dict, let’s name it fitting_key, together frozen in graph_{fitting_key}.pb. Those frozen models are exactly the same as single-task output with fitting net fitting_key.
Compress a model
Once the frozen model is obtained from DeePMD-kit, we can get the neural network structure and its parameters (weights, biases, etc.) from the trained model, and compress it in the following way:
dp compress -i graph.pb -o graph-compress.pb
where -i gives the original frozen model, -o gives the compressed model. Several other command line options can be passed to dp compress, which can be checked with
$ dp compress --help
An explanation will be provided
usage: dp compress [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-m {master,collect,workers}] [-i INPUT] [-o OUTPUT]
[-s STEP] [-e EXTRAPOLATE] [-f FREQUENCY]
[-c CHECKPOINT_FOLDER]
optional arguments:
-h, --help show this help message and exit
-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}, --log-level {DEBUG,3,INFO,2,WARNING,1,ERROR,0}
set verbosity level by string or number, 0=ERROR,
1=WARNING, 2=INFO and 3=DEBUG (default: INFO)
-l LOG_PATH, --log-path LOG_PATH
set log file to log messages to disk, if not
specified, the logs will only be output to console
(default: None)
-m {master,collect,workers}, --mpi-log {master,collect,workers}
Set the manner of logging when running with MPI.
'master' logs only on main process, 'collect'
broadcasts logs from workers to master and 'workers'
means each process will output its own log (default:
master)
-i INPUT, --input INPUT
The original frozen model, which will be compressed by
the code (default: frozen_model.pb)
-o OUTPUT, --output OUTPUT
The compressed model (default:
frozen_model_compressed.pb)
-s STEP, --step STEP Model compression uses fifth-order polynomials to
interpolate the embedding-net. It introduces two
tables with different step size to store the
parameters of the polynomials. The first table covers
the range of the training data, while the second table
is an extrapolation of the training data. The domain
of each table is uniformly divided by a given step
size. And the step(parameter) denotes the step size of
the first table and the second table will use 10 *
step as it's step size to save the memory. Usually the
value ranges from 0.1 to 0.001. Smaller step means
higher accuracy and bigger model size (default: 0.01)
-e EXTRAPOLATE, --extrapolate EXTRAPOLATE
The domain range of the first table is automatically
detected by the code: [d_low, d_up]. While the second
table ranges from the first table's upper
boundary(d_up) to the extrapolate(parameter) * d_up:
[d_up, extrapolate * d_up] (default: 5)
-f FREQUENCY, --frequency FREQUENCY
The frequency of tabulation overflow check(Whether the
input environment matrix overflow the first or second
table range). By default do not check the overflow
(default: -1)
-c CHECKPOINT_FOLDER, --checkpoint-folder CHECKPOINT_FOLDER
path to checkpoint folder (default: .)
-t TRAINING_SCRIPT, --training-script TRAINING_SCRIPT
The training script of the input frozen model
(default: None)
Parameter explanation
Model compression, which includes tabulating the embedding net. The table is composed of fifth-order polynomial coefficients and is assembled from two sub-tables. For model descriptor with se_e2_a type, the first sub-table takes the stride(parameter) as its uniform stride, while the second sub-table takes 10 * stride as its uniform stride; For model descriptor with se_e3 type, the first sub-table takes 10 * stride as it’s uniform stride, while the second sub-table takes 100 * 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. Finally, we added a check frequency parameter. It indicates how often the program checks for overflow(if the input environment matrix overflows the first or second table range) during the MD inference.
Justification of model compression
Model compression, with little loss of accuracy, can greatly speed up MD inference time. According to different simulation systems and training parameters, the speedup can reach more than 10 times at both CPU and GPU devices. At the same time, model compression can greatly change memory usage, reducing as much as 20 times under the same hardware conditions.
Acceptable original model version
The model compression interface requires the version of DeePMD-kit used in the original model generation should be 2.0.0-alpha.0 or above. If one has a frozen 1.2 or 1.3 model, one can upgrade it through the dp convert-from interface. (eg: dp convert-from 1.2/1.3 -i old_frozen_model.pb -o new_frozen_model.pb)
Acceptable descriptor type
Descriptors with se_e2_a, se_e3, and se_e2_r types are supported by the model compression feature. Hybrid mixed with the above descriptors is also supported.
Available activation functions for descriptor:
tanh
gelu
relu
relu6
softplus
sigmoid
Test
Test a model
The frozen model can be used in many ways. The most straightforward test can be performed using dp test. A typical usage of dp test is
dp test -m graph.pb -s /path/to/system -n 30
where -m gives the tested model, -s the path to the tested system and -n the number of tested frames. Several other command line options can be passed to dp test, which can be checked with
$ dp test --help
An explanation will be provided
usage: dp test [-h] [-m MODEL] [-s SYSTEM] [-S SET_PREFIX] [-n NUMB_TEST]
[-r RAND_SEED] [--shuffle-test] [-d DETAIL_FILE]
optional arguments:
-h, --help show this help message and exit
-m MODEL, --model MODEL
Frozen model file to import
-s SYSTEM, --system SYSTEM
The system dir
-S SET_PREFIX, --set-prefix SET_PREFIX
The set prefix
-n NUMB_TEST, --numb-test NUMB_TEST
The number of data for test
-r RAND_SEED, --rand-seed RAND_SEED
The random seed
--shuffle-test Shuffle test data
-d DETAIL_FILE, --detail-file DETAIL_FILE
The prefix to files where details of energy, force and virial accuracy/accuracy per atom will be written
-a, --atomic Test the accuracy of atomic label, i.e. energy / tensor (dipole, polar)
Calculate Model Deviation
One can also use a subcommand to calculate the deviation of predicted forces or virials for a bunch of models in the following way:
dp model-devi -m graph.000.pb graph.001.pb graph.002.pb graph.003.pb -s ./data -o model_devi.out
where -m specifies graph files to be calculated, -s gives the data to be evaluated, -o the file to which model deviation results is dumped. Here is more information on this sub-command:
usage: dp model-devi [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}]
[-l LOG_PATH] [-m MODELS [MODELS ...]] [-s SYSTEM]
[-S SET_PREFIX] [-o OUTPUT] [-f FREQUENCY] [-i ITEMS]
optional arguments:
-h, --help show this help message and exit
-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}, --log-level {DEBUG,3,INFO,2,WARNING,1,ERROR,0}
set verbosity level by string or number, 0=ERROR,
1=WARNING, 2=INFO and 3=DEBUG (default: INFO)
-l LOG_PATH, --log-path LOG_PATH
set log file to log messages to disk, if not
specified, the logs will only be output to console
(default: None)
-m MODELS [MODELS ...], --models MODELS [MODELS ...]
Frozen models file to import (default:
['graph.000.pb', 'graph.001.pb', 'graph.002.pb',
'graph.003.pb'])
-s SYSTEM, --system SYSTEM
The system directory, not support recursive detection.
(default: .)
-S SET_PREFIX, --set-prefix SET_PREFIX
The set prefix (default: set)
-o OUTPUT, --output OUTPUT
The output file for results of model deviation
(default: model_devi.out)
-f FREQUENCY, --frequency FREQUENCY
The trajectory frequency of the system (default: 1)
For more details concerning the definition of model deviation and its application, please refer to Yuzhi Zhang, Haidi Wang, Weijie Chen, Jinzhe Zeng, Linfeng Zhang, Han Wang, and Weinan E, DP-GEN: A concurrent learning platform for the generation of reliable deep learning based potential energy models, Computer Physics Communications, 2020, 253, 107206.
Inference
Note that the model for inference is required to be compatible with the DeePMD-kit package. See Model compatibility for details.
Python interface
One may use the python interface of DeePMD-kit for model inference, an example is given as follows
from deepmd.infer import DeepPot
import numpy as np
dp = DeepPot('graph.pb')
coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1])
cell = np.diag(10 * np.ones(3)).reshape([1, -1])
atype = [1,0,1]
e, f, v = dp.eval(coord, cell, atype)
where e, f and v are predicted energy, force and virial of the system, respectively.
Furthermore, one can use the python interface to calculate model deviation.
from deepmd.infer import calc_model_devi
from deepmd.infer import DeepPot as DP
import numpy as np
coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1])
cell = np.diag(10 * np.ones(3)).reshape([1, -1])
atype = [1,0,1]
graphs = [DP("graph.000.pb"), DP("graph.001.pb")]
model_devi = calc_model_devi(coord, cell, atype, graphs)
Note that if the model inference or model deviation is performed cyclically, one should avoid calling the same model multiple times. Otherwise, tensorFlow will never release the memory and this may lead to an out-of-memory (OOM) error.
C/C++ interface
C++ interface
The C++ interface of DeePMD-kit is also available for the model interface, which is considered faster than the Python interface. An example infer_water.cpp is given below:
#include "deepmd/DeepPot.h"
int main(){
deepmd::DeepPot dp ("graph.pb");
std::vector<double > coord = {1., 0., 0., 0., 0., 1.5, 1. ,0. ,3.};
std::vector<double > cell = {10., 0., 0., 0., 10., 0., 0., 0., 10.};
std::vector<int > atype = {1, 0, 1};
double e;
std::vector<double > f, v;
dp.compute (e, f, v, coord, atype, cell);
}
where e, f and v are predicted energy, force and virial of the system, respectively. See deepmd::DeepPot for details.
You can compile infer_water.cpp using gcc:
gcc infer_water.cpp -L $deepmd_root/lib -L $tensorflow_root/lib -I $deepmd_root/include -Wl,--no-as-needed -ldeepmd_cc -lstdc++ -ltensorflow_cc -Wl,-rpath=$deepmd_root/lib -Wl,-rpath=$tensorflow_root/lib -o infer_water
and then run the program:
./infer_water
C interface
Although C is harder to write, the C library will not be affected by different versions of C++ compilers.
An example infer_water.c is given below:
#include <stdio.h>
#include <stdlib.h>
#include "deepmd/c_api.h"
int main(){
const char* model = "graph.pb";
double coord[] = {1., 0., 0., 0., 0., 1.5, 1. ,0. ,3.};
double cell[] = {10., 0., 0., 0., 10., 0., 0., 0., 10.};
int atype[] = {1, 0, 1};
// init C pointers with given memory
double* e = malloc(sizeof(*e));
double* f = malloc(sizeof(*f) * 9); // natoms * 3
double* v = malloc(sizeof(*v) * 9);
double* ae = malloc(sizeof(*ae) * 9); // natoms
double* av = malloc(sizeof(*av) * 27); // natoms * 9
// DP model
DP_DeepPot* dp = DP_NewDeepPot(model);
DP_DeepPotCompute (dp, 3, coord, atype, cell, e, f, v, ae, av);
// print results
printf("energy: %f\n", *e);
for (int ii = 0; ii < 9; ++ii)
printf("force[%d]: %f\n", ii, f[ii]);
for (int ii = 0; ii < 9; ++ii)
printf("force[%d]: %f\n", ii, v[ii]);
// free memory
free(e);
free(f);
free(v);
free(ae);
free(av);
free(dp);
}
where e, f and v are predicted energy, force and virial of the system, respectively. ae and av are atomic energy and atomic virials, respectively. See DP_DeepPotCompute() for details.
You can compile infer_water.c using gcc:
gcc infer_water.c -L $deepmd_root/lib -L $tensorflow_root/lib -I $deepmd_root/include -Wl,--no-as-needed -ldeepmd_c -Wl,-rpath=$deepmd_root/lib -Wl,-rpath=$tensorflow_root/lib -o infer_water
and then run the program:
./infer_water
Header-only C++ library interface (recommended)
The header-only C++ library is built based on the C library. Thus, it has the same ABI compatibility as the C library but provides a powerful C++ interface. To use it, include deepmd/deepmd.hpp.
#include "deepmd/deepmd.hpp"
int main(){
deepmd::hpp::DeepPot dp ("graph.pb");
std::vector<double > coord = {1., 0., 0., 0., 0., 1.5, 1. ,0. ,3.};
std::vector<double > cell = {10., 0., 0., 0., 10., 0., 0., 0., 10.};
std::vector<int > atype = {1, 0, 1};
double e;
std::vector<double > f, v;
dp.compute (e, f, v, coord, atype, cell);
}
Note that the feature of the header-only C++ library is still limited compared to the original C++ library. See deepmd::hpp::DeepPot for details.
You can compile infer_water_hpp.cpp using gcc:
gcc infer_water_hpp.hpp -L $deepmd_root/lib -L $tensorflow_root/lib -I $deepmd_root/include -Wl,--no-as-needed -ldeepmd_c -Wl,-rpath=$deepmd_root/lib -Wl,-rpath=$tensorflow_root/lib -o infer_water_hpp
and then run the program:
./infer_water_hpp
In some cases, one may want to pass the custom neighbor list instead of the native neighbor list. The above code can be revised as follows:
// neighbor list
std::vector<std::vector<int >> nlist_vec = {
{1, 2},
{0, 2},
{0, 1}
};
std::vector<int> ilist(3), numneigh(3);
std::vector<int*> firstneigh(3);
InputNlist nlist(3, &ilist[0], &numneigh[0], &firstneigh[0]);
convert_nlist(nlist, nlist_vec);
dp.compute (e, f, v, coord, atype, cell, 0, nlist, 0);
Here, nlist_vec means the neighbors of atom 0 are atom 1 and atom 2, the neighbors of atom 1 are atom 0 and atom 2, and the neighbors of atom 2 are atom 0 and atom 1.
Command line interface
DeePMD-kit: A deep learning package for many-body potential energy representation and molecular dynamics
usage: dp [-h] [--version]
{config,transfer,train,freeze,test,compress,doc-train-input,model-devi,convert-from,neighbor-stat,train-nvnmd}
...
Named Arguments
- --version
show program’s version number and exit
Valid subcommands
- command
Possible choices: config, transfer, train, freeze, test, compress, doc-train-input, model-devi, convert-from, neighbor-stat, train-nvnmd
Sub-commands
config
fast configuration of parameter file for smooth model
dp config [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-o OUTPUT]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -o, --output
the output json file
Default: “input.json”
transfer
pass parameters to another model
dp transfer [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-r RAW_MODEL] [-O OLD_MODEL] [-o OUTPUT]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -r, --raw-model
the model receiving parameters
Default: “raw_frozen_model.pb”
- -O, --old-model
the model providing parameters
Default: “old_frozen_model.pb”
- -o, --output
the model after passing parameters
Default: “frozen_model.pb”
train
train a model
dp train [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-m {master,collect,workers}]
[-i INIT_MODEL | -r RESTART | -f INIT_FRZ_MODEL | -t FINETUNE]
[-o OUTPUT] [--skip-neighbor-stat]
INPUT
Positional Arguments
- INPUT
the input parameter file in json or yaml format
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -m, --mpi-log
Possible choices: master, collect, workers
Set the manner of logging when running with MPI. ‘master’ logs only on main process, ‘collect’ broadcasts logs from workers to master and ‘workers’ means each process will output its own log
Default: “master”
- -i, --init-model
Initialize the model by the provided checkpoint.
- -r, --restart
Restart the training from the provided checkpoint.
- -f, --init-frz-model
Initialize the training from the frozen model.
- -t, --finetune
Finetune the frozen pretrained model.
- -o, --output
The output file of the parameters used in training.
Default: “out.json”
- --skip-neighbor-stat
Skip calculating neighbor statistics. Sel checking, automatic sel, and model compression will be disabled.
Default: False
- examples:
dp train input.json dp train input.json –restart model.ckpt dp train input.json –init-model model.ckpt
freeze
freeze the model
dp freeze [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-c CHECKPOINT_FOLDER] [-o OUTPUT] [-n NODE_NAMES] [-w NVNMD_WEIGHT]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -c, --checkpoint-folder
path to checkpoint folder
Default: “.”
- -o, --output
name of graph, will output to the checkpoint folder
Default: “frozen_model.pb”
- -n, --node-names
the frozen nodes, if not set, determined from the model type
- -w, --nvnmd-weight
the name of weight file (.npy), if set, save the model’s weight into the file
- examples:
dp freeze dp freeze -o graph.pb
test
test the model
dp test [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH] [-m MODEL]
[-s SYSTEM] [-S SET_PREFIX] [-n NUMB_TEST] [-r RAND_SEED]
[--shuffle-test] [-d DETAIL_FILE] [-a]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -m, --model
Frozen model file to import
Default: “frozen_model.pb”
- -s, --system
The system dir. Recursively detect systems in this directory
Default: “.”
- -S, --set-prefix
The set prefix
Default: “set”
- -n, --numb-test
The number of data for test
Default: 100
- -r, --rand-seed
The random seed
- --shuffle-test
Shuffle test data
Default: False
- -d, --detail-file
The prefix to files where details of energy, force and virial accuracy/accuracy per atom will be written
- -a, --atomic
Test the accuracy of atomic label, i.e. energy / tensor (dipole, polar)
Default: False
- examples:
dp test -m graph.pb -s /path/to/system -n 30
compress
compress a model
dp compress [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-m {master,collect,workers}] [-i INPUT] [-o OUTPUT] [-s STEP]
[-e EXTRAPOLATE] [-f FREQUENCY] [-c CHECKPOINT_FOLDER]
[-t TRAINING_SCRIPT]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -m, --mpi-log
Possible choices: master, collect, workers
Set the manner of logging when running with MPI. ‘master’ logs only on main process, ‘collect’ broadcasts logs from workers to master and ‘workers’ means each process will output its own log
Default: “master”
- -i, --input
The original frozen model, which will be compressed by the code
Default: “frozen_model.pb”
- -o, --output
The compressed model
Default: “frozen_model_compressed.pb”
- -s, --step
Model compression uses fifth-order polynomials to interpolate the embedding-net. It introduces two tables with different step size to store the parameters of the polynomials. The first table covers the range of the training data, while the second table is an extrapolation of the training data. The domain of each table is uniformly divided by a given step size. And the step(parameter) denotes the step size of the first table and the second table will use 10 * step as it’s step size to save the memory. Usually the value ranges from 0.1 to 0.001. Smaller step means higher accuracy and bigger model size
Default: 0.01
- -e, --extrapolate
The domain range of the first table is automatically detected by the code: [d_low, d_up]. While the second table ranges from the first table’s upper boundary(d_up) to the extrapolate(parameter) * d_up: [d_up, extrapolate * d_up]
Default: 5
- -f, --frequency
The frequency of tabulation overflow check(Whether the input environment matrix overflow the first or second table range). By default do not check the overflow
Default: -1
- -c, --checkpoint-folder
path to checkpoint folder
Default: “model-compression”
- -t, --training-script
The training script of the input frozen model
- examples:
dp compress dp compress -i graph.pb -o compressed.pb
doc-train-input
print the documentation (in rst format) of input training parameters.
dp doc-train-input [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[--out-type OUT_TYPE]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- --out-type
The output type
Default: “rst”
model-devi
calculate model deviation
dp model-devi [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-m MODELS [MODELS ...]] [-s SYSTEM] [-S SET_PREFIX] [-o OUTPUT]
[-f FREQUENCY]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -m, --models
Frozen models file to import
Default: [‘graph.000.pb’, ‘graph.001.pb’, ‘graph.002.pb’, ‘graph.003.pb’]
- -s, --system
The system directory. Recursively detect systems in this directory.
Default: “.”
- -S, --set-prefix
The set prefix
Default: “set”
- -o, --output
The output file for results of model deviation
Default: “model_devi.out”
- -f, --frequency
The trajectory frequency of the system
Default: 1
- examples:
dp model-devi -m graph.000.pb graph.001.pb graph.002.pb graph.003.pb -s ./data -o model_devi.out
convert-from
convert lower model version to supported version
dp convert-from [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-i INPUT_MODEL] [-o OUTPUT_MODEL]
{0.12,1.0,1.1,1.2,1.3,2.0,pbtxt}
Positional Arguments
- FROM
Possible choices: 0.12, 1.0, 1.1, 1.2, 1.3, 2.0, pbtxt
The original model compatibility
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -i, --input-model
the input model
Default: “frozen_model.pb”
- -o, --output-model
the output model
Default: “convert_out.pb”
- examples:
dp convert-from 1.0 -i graph.pb -o graph_new.pb
neighbor-stat
Calculate neighbor statistics
dp neighbor-stat [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-s SYSTEM] -r RCUT -t TYPE_MAP [TYPE_MAP ...] [--one-type]
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -s, --system
The system dir. Recursively detect systems in this directory
Default: “.”
- -r, --rcut
cutoff radius
- -t, --type-map
type map
- --one-type
treat all types as a single type. Used with se_atten descriptor.
Default: False
- examples:
dp neighbor-stat -s data -r 6.0 -t O H
train-nvnmd
train nvnmd model
dp train-nvnmd [-h] [-v {DEBUG,3,INFO,2,WARNING,1,ERROR,0}] [-l LOG_PATH]
[-s {s1,s2}]
INPUT
Positional Arguments
- INPUT
the input parameter file in json format
Named Arguments
- -v, --log-level
Possible choices: DEBUG, 3, INFO, 2, WARNING, 1, ERROR, 0
set verbosity level by string or number, 0=ERROR, 1=WARNING, 2=INFO and 3=DEBUG
Default: “INFO”
- -l, --log-path
set log file to log messages to disk, if not specified, the logs will only be output to console
- -s, --step
Possible choices: s1, s2
steps to train model of NVNMD: s1 (train CNN), s2 (train QNN)
Default: “s1”
Integrate with third-party packages
Note that the model for inference is required to be compatible with the DeePMD-kit package. See Model compatibility for details.
Use deep potential with ASE
Deep potential can be set up as a calculator with ASE to obtain potential energies and forces.
from ase import Atoms
from deepmd.calculator import DP
water = Atoms('H2O',
positions=[(0.7601, 1.9270, 1),
(1.9575, 1, 1),
(1., 1., 1.)],
cell=[100, 100, 100],
calculator=DP(model="frozen_model.pb"))
print(water.get_potential_energy())
print(water.get_forces())
Optimization is also available:
from ase.optimize import BFGS
dyn = BFGS(water)
dyn.run(fmax=1e-6)
print(water.get_positions())
Run MD with LAMMPS
Running an MD simulation with LAMMPS is simpler. In the LAMMPS input file, one needs to specify the pair style as follows
pair_style deepmd graph.pb
pair_coeff * *
where graph.pb is the file name of the frozen model. It should be noted that LAMMPS counts atom types starting from 1, therefore, all LAMMPS atom types will be firstly subtracted by 1, and then passed into the DeePMD-kit engine to compute the interactions.
LAMMPS commands
Enable DeePMD-kit plugin (plugin mode)
If you are using the plugin mode, enable DeePMD-kit package in LAMMPS with plugin command:
plugin load libdeepmd_lmp.so
After LAMMPS version patch_24Mar2022, another way to load plugins is to set the environmental variable LAMMPS_PLUGIN_PATH:
LAMMPS_PLUGIN_PATH=$deepmd_root/lib/deepmd_lmp
where $deepmd_root is the directory to install C++ interface.
The built-in mode doesn’t need this step.
pair_style deepmd
The DeePMD-kit package provides the pair_style deepmd
pair_style deepmd models ... keyword value ...
deepmd = style of this pair_style
models = frozen model(s) to compute the interaction. If multiple models are provided, then only the first model serves to provide energy and force prediction for each timestep of molecular dynamics, and the model deviation will be computed among all models every
out_freqtimesteps.keyword = out_file or out_freq or fparam or atomic or relative or relative_v or aparam or ttm
out_file value = filename
filename = The file name for the model deviation output. Default is model_devi.out
out_freq value = freq
freq = Frequency for the model deviation output. Default is 100.
fparam value = parameters
parameters = one or more frame parameters required for model evaluation.
atomic = no value is required.
If this keyword is set, the model deviation of each atom will be output.
relative value = level
level = The level parameter for computing the relative model deviation of the force
relative_v value = level
level = The level parameter for computing the relative model deviation of the virial
aparam value = parameters
parameters = one or more atomic parameters of each atom required for model evaluation
ttm value = id
id = fix ID of fix ttm
Examples
pair_style deepmd graph.pb
pair_style deepmd graph.pb fparam 1.2
pair_style deepmd graph_0.pb graph_1.pb graph_2.pb out_file md.out out_freq 10 atomic relative 1.0
Description
Evaluate the interaction of the system by using Deep Potential or Deep Potential Smooth Edition. It is noticed that deep potential is not a “pairwise” interaction, but a multi-body interaction.
This pair style takes the deep potential defined in a model file that usually has the .pb extension. The model can be trained and frozen by package DeePMD-kit.
The model deviation evalulates the consistency of the force predictions from multiple models. By default, only the maximal, minimal and average model deviations are output. If the key atomic is set, then the model deviation of force prediction of each atom will be output.
By default, the model deviation is output in absolute value. If the keyword relative is set, then the relative model deviation of the force will be output, including values output by the keyword atomic. The relative model deviation of the force on atom \(i\) is defined by
where \(D_{f_i}\) is the absolute model deviation of the force on atom \(i\), \(f_i\) is the norm of the force and \(l\) is provided as the parameter of the keyword relative. If the keyword relative_v is set, then the relative model deviation of the virial will be output instead of the absolute value, with the same definition of that of the force:
If the keyword fparam is set, the given frame parameter(s) will be fed to the model. If the keyword aparam is set, the given atomic parameter(s) will be fed to the model, where each atom is assumed to have the same atomic parameter(s). If the keyword ttm is set, electronic temperatures from fix ttm command will be fed to the model as the atomic parameters.
Restrictions
The
deepmdpair style is provided in the USER-DEEPMD package, which is compiled from the DeePMD-kit, visit the DeePMD-kit website for more information.
Compute tensorial properties
The DeePMD-kit package provides the compute deeptensor/atom for computing atomic tensorial properties.
compute ID group-ID deeptensor/atom model_file
ID: user-assigned name of the computation
group-ID: ID of the group of atoms to compute
deeptensor/atom: the style of this compute
model_file: the name of the binary model file.
Examples
compute dipole all deeptensor/atom dipole.pb
The result of the compute can be dumped to trajectory file by
dump 1 all custom 100 water.dump id type c_dipole[1] c_dipole[2] c_dipole[3]
Restrictions
The
deeptensor/atomcompute is provided in the USER-DEEPMD package, which is compiled from the DeePMD-kit, visit the DeePMD-kit website for more information.
Long-range interaction
The reciprocal space part of the long-range interaction can be calculated by LAMMPS command kspace_style. To use it with DeePMD-kit, one writes
pair_style deepmd graph.pb
pair_coeff * *
kspace_style pppm 1.0e-5
kspace_modify gewald 0.45
Please notice that the DeePMD does nothing to the direct space part of the electrostatic interaction, because this part is assumed to be fitted in the DeePMD model (the direct space cut-off is thus the cut-off of the DeePMD model). The splitting parameter gewald is modified by the kspace_modify command.
Use of the centroid/stress/atom to get the full 3x3 “atomic-virial”
The DeePMD-kit allows also the computation of per-atom stress tensor defined as:
Where \(\mathbf{r}_n\) is the atomic position of nth atom, \(\mathbf{v}_n\) velocity of the atom and \(\frac{de_m}{d\mathbf{r}_n}\) the derivative of the atomic energy.
In LAMMPS one can get the per-atom stress using the command centroid/stress/atom:
compute ID group-ID centroid/stress/atom NULL virial
see LAMMPS doc page for more details on the meaning of the keywords.
Examples
In order of computing the 9-component per-atom stress
compute stress all centroid/stress/atom NULL virial
Thus c_stress is an array with 9 components in the order xx,yy,zz,xy,xz,yz,yx,zx,zy.
If you use this feature please cite D. Tisi, L. Zhang, R. Bertossa, H. Wang, R. Car, S. Baroni - arXiv preprint arXiv:2108.10850, 2021
Computation of heat flux
Using a per-atom stress tensor one can, for example, compute the heat flux defined as:
to compute the heat flux with LAMMPS:
compute ke_ID all ke/atom
compute pe_ID all pe/atom
compute stress_ID group-ID centroid/stress/atom NULL virial
compute flux_ID all heat/flux ke_ID pe_ID stress_ID
Examples
compute ke all ke/atom
compute pe all pe/atom
compute stress all centroid/stress/atom NULL virial
compute flux all heat/flux ke pe stress
c_flux is a global vector of length 6. The first three components are the \(x\), \(y\) and \(z\) components of the full heat flux vector. The others are the components of the so-called convective portion, see LAMMPS doc page for more detailes.
If you use these features please cite D. Tisi, L. Zhang, R. Bertossa, H. Wang, R. Car, S. Baroni - arXiv preprint arXiv:2108.10850, 2021
Run path-integral MD with i-PI
The i-PI works in a client-server model. The i-PI provides the server for integrating the replica positions of atoms, while the DeePMD-kit provides a client named dp_ipi (or dp_ipi_low for low precision) that computes the interactions (including energy, forces and virials). The server and client communicate via the Unix domain socket or the Internet socket. Installation instructions for i-PI can be found here. The client can be started by
i-pi input.xml &
dp_ipi water.json
It is noted that multiple instances of the client allow for computing, in parallel, the interactions of multiple replicas of the path-integral MD.
water.json is the parameter file for the client dp_ipi, and an example is provided:
{
"verbose": false,
"use_unix": true,
"port": 31415,
"host": "localhost",
"graph_file": "graph.pb",
"coord_file": "conf.xyz",
"atom_type" : {
"OW": 0,
"HW1": 1,
"HW2": 1
}
}
The option use_unix is set to true to activate the Unix domain socket, otherwise, the Internet socket is used.
The option port should be the same as that in input.xml:
<port>31415</port>
The option graph_file provides the file name of the frozen model.
The dp_ipi gets the atom names from an XYZ file provided by coord_file (meanwhile ignores all coordinates in it) and translates the names to atom types by rules provided by atom_type.
Running MD with GROMACS
DP/MM Simulation
This part gives a simple tutorial on how to run a DP/MM simulation for methane in water, which means using DP for methane and TIP3P for water. All relevant files can be found in examples/methane.
Topology Preparation
Similar to QM/MM simulation, the internal interactions (including bond, angle, dihedrals, LJ, Columb) of the region described by a neural network potential (NNP) have to be turned off. In GROMACS, bonded interactions can be turned off by modifying [ bonds ], [ angles ], [ dihedrals ] and [ pairs ] sections. And LJ and Columb interactions must be turned off by [ exclusions ] section.
For example, if one wants to simulate ethane in water, using DeepPotential for methane and TIP3P for water, the topology of methane should be like the following (as presented in examples/methane/methane.itp):
[ atomtypes ]
;name btype mass charge ptype sigma epsilon
c3 c3 0.0 0.0 A 0.339771 0.451035
hc hc 0.0 0.0 A 0.260018 0.087027
[ moleculetype ]
;name nrexcl
methane 3
[ atoms ]
; nr type resnr residue atom cgnr charge mass
1 c3 1 MOL C1 1 -0.1068 12.010
2 hc 1 MOL H1 2 0.0267 1.008
3 hc 1 MOL H2 3 0.0267 1.008
4 hc 1 MOL H3 4 0.0267 1.008
5 hc 1 MOL H4 5 0.0267 1.008
[ bonds ]
; i j func b0 kb
1 2 5
1 3 5
1 4 5
1 5 5
[ exclusions ]
; ai aj1 aj2 aj3 aj4
1 2 3 4 5
2 1 3 4 5
3 1 2 4 5
4 1 2 3 5
5 1 2 3 4
For comparison, the original topology file generated by acpype will be:
; methane_GMX.itp created by acpype (v: 2021-02-05T22:15:50CET) on Wed Sep 8 01:21:53 2021
[ atomtypes ]
;name bond_type mass charge ptype sigma epsilon Amb
c3 c3 0.00000 0.00000 A 3.39771e-01 4.51035e-01 ; 1.91 0.1078
hc hc 0.00000 0.00000 A 2.60018e-01 8.70272e-02 ; 1.46 0.0208
[ moleculetype ]
;name nrexcl
methane 3
[ atoms ]
; nr type resi res atom cgnr charge mass ; qtot bond_type
1 c3 1 MOL C1 1 -0.106800 12.01000 ; qtot -0.107
2 hc 1 MOL H1 2 0.026700 1.00800 ; qtot -0.080
3 hc 1 MOL H2 3 0.026700 1.00800 ; qtot -0.053
4 hc 1 MOL H3 4 0.026700 1.00800 ; qtot -0.027
5 hc 1 MOL H4 5 0.026700 1.00800 ; qtot 0.000
[ bonds ]
; ai aj funct r k
1 2 1 1.0970e-01 3.1455e+05 ; C1 - H1
1 3 1 1.0970e-01 3.1455e+05 ; C1 - H2
1 4 1 1.0970e-01 3.1455e+05 ; C1 - H3
1 5 1 1.0970e-01 3.1455e+05 ; C1 - H4
[ angles ]
; ai aj ak funct theta cth
2 1 3 1 1.0758e+02 3.2635e+02 ; H1 - C1 - H2
2 1 4 1 1.0758e+02 3.2635e+02 ; H1 - C1 - H3
2 1 5 1 1.0758e+02 3.2635e+02 ; H1 - C1 - H4
3 1 4 1 1.0758e+02 3.2635e+02 ; H2 - C1 - H3
3 1 5 1 1.0758e+02 3.2635e+02 ; H2 - C1 - H4
4 1 5 1 1.0758e+02 3.2635e+02 ; H3 - C1 - H4
DeepMD Settings
Before running simulations, we need to tell GROMACS to use DeepPotential by setting the environment variable GMX_DEEPMD_INPUT_JSON:
export GMX_DEEPMD_INPUT_JSON=input.json
Then, in your working directories, we have to write input.json file:
{
"graph_file": "/path/to/graph.pb",
"type_file": "type.raw",
"index_file": "index.raw",
"lambda": 1.0,
"pbc": false
}
Here is an explanation for these settings:
graph_file: The graph file (with suffix .pb) generated bydp freezecommandtype_file: File to specify DP atom types (in space-separated format). Here,type.rawlooks like
1 0 0 0 0
index_file: File containing indices of DP atoms (in space-separated format), which should be consistent with the indices’ order in .gro file but starting from zero. Here,index.rawlooks like
0 1 2 3 4
lambda: Optional, default 1.0. Used in alchemical calculations.pbc: Optional, default true. If true, the GROMACS periodic condition is passed to DeepMD.
Run Simulation
Finally, you can run GROMACS using gmx mdrun as usual.
All-atom DP Simulation
This part gives an example of how to simulate all atoms described by a DeepPotential with Gromacs, taking water as an example. Instead of using [ exclusions ] to turn off the non-bonded energies, we can simply do this by setting LJ parameters (i.e. epsilon and sigma) and partial charges to 0, as shown in examples/water/gmx/water.top:
[ atomtypes ]
; name at.num mass charge ptype sigma epsilon
HW 1 1.008 0.0000 A 0.00000e+00 0.00000e+00
OW 8 16.00 0.0000 A 0.00000e+00 0.00000e+00
As mentioned in the above section, input.json and relevant files (index.raw, type.raw) should also be created. Then, we can start the simulation under the NVT ensemble and plot the radial distribution function (RDF) by gmx rdf command. We can see that the RDF given by Gromacs+DP matches perfectly with Lammps+DP, which further provides an evidence on the validity of our simulation. 
However, we still recommend you run an all-atom DP simulation using LAMMPS since it is more stable and efficient.
Interfaces out of DeePMD-kit
The codes of the following interfaces are not a part of the DeePMD-kit package and maintained by other repositories. We list these interfaces here for user convenience.
dpdata
dpdata provides the predict method for System class:
import dpdata
dsys = dpdata.LabeledSystem('OUTCAR')
dp_sys = dsys.predict("frozen_model_compressed.pb")
By inferring with the DP model frozen_model_compressed.pb, dpdata will generate a new labeled system dp_sys with inferred energies, forces, and virials.
OpenMM plugin for DeePMD-kit
An OpenMM plugin is provided from JingHuangLab/openmm_deepmd_plugin, written by the Huang Lab at Westlake University.
AMBER interface to DeePMD-kit
An AMBER interface to DeePMD-kit is written by the [York Lab from Rutgers University. It is open-source at GitLab RutgersLBSR/AmberDPRc. Details can be found in this paper.
DP-GEN
DP-GEN provides a workflow to generate accurate DP models by calling DeePMD-kit’s command line interface (CLI) in the local or remote server. Details can be found in this paper.
MLatom
Mlatom provides an interface to the DeePMD-kit within MLatom’s workflow by calling DeePMD-kit’s CLI. Details can be found in this paper.
Use NVNMD
Introduction
NVNMD stands for non-von Neumann molecular dynamics.
This is the training code we used to generate the results in our paper entitled “Accurate and Efficient Molecular Dynamics based on Machine Learning and non von Neumann Architecture”, which has been accepted by npj Computational Materials (DOI: 10.1038/s41524-022-00773-z).
Any user can follow two consecutive steps to run molecular dynamics (MD) on the proposed NVNMD computer, which has been released online: (i) to train a machine learning (ML) model that can decently reproduce the potential energy surface (PES); and (ii) to deploy the trained ML model on the proposed NVNMD computer, then run MD there to obtain the atomistic trajectories.
Training
Our training procedure consists of not only continuous neural network (CNN) training but also quantized neural network (QNN) training which uses the results of CNN as inputs. It is performed on CPU or GPU by using the training codes we open-sourced online.
To train an ML model that can decently reproduce the PES, a training and testing data set should be prepared first. This can be done by using either the state-of-the-art active learning tools or the outdated (i.e., less efficient) brute-force density functional theory (DFT)-based ab-initio molecular dynamics (AIMD) sampling.
If you just want to simply test the training function, you can use the example in the $deepmd_source_dir/examples/nvnmd directory. If you want to fully experience training and running MD functions, you can download the complete example from the website.
Then, copy the data set to the working directory
mkdir -p $workspace
cd $workspace
mkdir -p data
cp -r $dataset data
where $dataset is the path to the data set and $workspace is the path to the working directory.
Input script
Create and go to the training directory.
mkdir train
cd train
Then copy the input script train_cnn.json and train_qnn.json to the directory train
cp -r $deepmd_source_dir/examples/nvnmd/train/train_cnn.json train_cnn.json
cp -r $deepmd_source_dir/examples/nvnmd/train/train_qnn.json train_qnn.json
The structure of the input script is as follows
{
"nvnmd" : {},
"learning_rate" : {},
"loss" : {},
"training": {}
}
nvnmd
The “nvnmd” section is defined as
{
"net_size":128,
"sel":[60, 60],
"rcut":6.0,
"rcut_smth":0.5
}
where items are defined as:
Item | Mean | Optional Value |
|---|---|---|
net_size | the size of nueral network | 128 |
sel | the number of neighbors | integer list of lengths 1 to 4 are acceptable |
rcut | the cutoff radial | (0, 8.0] |
rcut_smth | the smooth cutoff parameter | (0, 8.0] |
learning_rate
The “learning_rate” section is defined as
{
"type":"exp",
"start_lr": 1e-3,
"stop_lr": 3e-8,
"decay_steps": 5000
}
where items are defined as:
Item | Mean | Optional Value |
|---|---|---|
type | learning rate variant type | exp |
start_lr | the learning rate at the beginning of the training | a positive real number |
stop_lr | the desired learning rate at the end of the training | a positive real number |
decay_stops | the learning rate is decaying every {decay_stops} training steps | a positive integer |
loss
The “loss” section is defined as
{
"start_pref_e": 0.02,
"limit_pref_e": 2,
"start_pref_f": 1000,
"limit_pref_f": 1,
"start_pref_v": 0,
"limit_pref_v": 0
}
where items are defined as:
Item | Mean | Optional Value |
|---|---|---|
start_pref_e | the loss factor of energy at the beginning of the training | zero or positive real number |
limit_pref_e | the loss factor of energy at the end of the training | zero or positive real number |
start_pref_f | the loss factor of force at the beginning of the training | zero or positive real number |
limit_pref_f | the loss factor of force at the end of the training | zero or positive real number |
start_pref_v | the loss factor of virial at the beginning of the training | zero or positive real number |
limit_pref_v | the loss factor of virial at the end of the training | zero or positive real number |
training
The “training” section is defined as
{
"seed": 1,
"stop_batch": 1000000,
"numb_test": 1,
"disp_file": "lcurve.out",
"disp_freq": 1000,
"save_ckpt": "model.ckpt",
"save_freq": 10000,
"training_data":{
"systems":["system1_path", "system2_path", "..."],
"set_prefix": "set",
"batch_size": ["batch_size_of_system1", "batch_size_of_system2", "..."]
}
}
where items are defined as:
Item | Mean | Optional Value |
|---|---|---|
seed | the randome seed | a integer |
stop_batch | the total training steps | a positive integer |
numb_test | the accuracy is test by using {numb_test} sample | a positive integer |
disp_file | the log file where the training message display | a string |
disp_freq | display frequency | a positive integer |
save_ckpt | check point file | a string |
save_freq | save frequency | a positive integer |
systems | a list of data directory which contains the dataset | string list |
set_prefix | the prefix of dataset | a string |
batch_size | a list of batch size of corresponding dataset | a integer list |
Training
Training can be invoked by
# step1: train CNN
dp train-nvnmd train_cnn.json -s s1
# step2: train QNN
dp train-nvnmd train_qnn.json -s s2
After the training process, you will get two folders: nvnmd_cnn and nvnmd_qnn. The nvnmd_cnn contains the model after continuous neural network (CNN) training. The nvnmd_qnn contains the model after quantized neural network (QNN) training. The binary file nvnmd_qnn/model.pb is the model file that is used to perform NVNMD in the server [http://nvnmd.picp.vip].
Testing
The frozen model can be used in many ways. The most straightforward testing can be invoked by
mkdir test
dp test -m ./nvnmd_qnn/frozen_model.pb -s path/to/system -d ./test/detail -n 99999 -l test/output.log
where the frozen model file to import is given via the -m command line flag, the path to the testing data set is given via the -s command line flag, and the file containing details of energy, forces and virials accuracy is given via the -d command line flag, the amount of data for testing is given via the -n command line flag.
Running MD
After CNN and QNN training, you can upload the ML model to our online NVNMD system and run MD there.
Account application
The server website of NVNMD is available at http://nvnmd.picp.vip. You can visit the URL and enter the login interface (Figure.1).
To obtain an account, please send your application to the email (jie_liu@hnu.edu.cn, liujie@uw.edu). The username and password will be sent to you by email.
Adding task
After successfully obtaining the account, enter the username and password in the login interface, and click “Login” to enter the homepage (Figure.2).
The homepage displays the remaining calculation time and all calculation records not deleted. Click Add a new task to enter the interface for adding a new task (Figure.3).
Task name: name of the task
Upload mode: two modes of uploading results to online data storage, including
Manual uploadandAutomatic upload. Results need to be uploaded manually to online data storage withManual uploadmode and will be uploaded automatically withAutomatic uploadmode.Input script: input file of the MD simulation.
In the input script, one needs to specify the pair style as follows
pair_style nvnmd model.pb
pair_coeff * *
Model file: the ML model named
model.pbobtained by QNN training.Data files: data files containing the information required for running an MD simulation (e.g.,
coord.lmpcontaining initial atom coordinates).
Next, you can click Submit to submit the task and then automatically return to the homepage (Figure.4).
Then, click Refresh to view the latest status of all calculation tasks.
Cancelling calculation
For the task whose calculation status is Pending and Running, you can click the corresponding Cancel on the homepage to stop the calculation (Figure.5).
Downloading results
For the task whose calculation status is Completed, Failed and Cancelled, you can click the corresponding Package or Separate files in the Download results bar on the homepage to download results.
Click Package to download a zipped package of all files including input files and output results (Figure.6).
Click Separate files to download the required separate files (Figure.7).
If Manual upload mode is selected or the file has expired, click Upload on the download interface to upload manually.
Deleting record
For the task no longer needed, you can click the corresponding Delete on the homepage to delete the record.
Records cannot be retrieved after deletion.
Clearing records
Click Clear calculation records on the homepage to clear all records.
Records cannot be retrieved after clearing.
FAQs
As a consequence of differences in computers or systems, problems may occur. Some common circumstances are listed as follows. In addition, some frequently asked questions are listed as follows. If other unexpected problems occur, you’re welcome to contact us for help.
How to tune Fitting/embedding-net size ?
Here are some test forms on fitting-net size tuning or embedding-net size tuning performed on several different systems.
Al2O3
Fitting net size tuning form on Al2O3: (embedding-net size: [25,50,100])
Fitting-net size | Energy L2err(eV) | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|---|
[240,240,240] | 1.742252e-02 | 7.259383e-05 | 4.014115e-02 |
[80,80,80] | 1.799349e-02 | 7.497287e-05 | 4.042977e-02 |
[40,40,40] | 1.799036e-02 | 7.495984e-05 | 4.068806e-02 |
[20,20,20] | 1.834032e-02 | 7.641801e-05 | 4.094784e-02 |
[10,10,10] | 1.913058e-02 | 7.971073e-05 | 4.154775e-02 |
[5,5,5] | 1.932914e-02 | 8.053808e-05 | 4.188052e-02 |
[4,4,4] | 1.944832e-02 | 8.103467e-05 | 4.217826e-02 |
[3,3,3] | 2.068631e-02 | 8.619296e-05 | 4.300497e-02 |
[2,2,2] | 2.267962e-02 | 9.449840e-05 | 4.413609e-02 |
[1,1,1] | 2.813596e-02 | 1.172332e-04 | 4.781115e-02 |
[] | 3.135002e-02 | 1.306251e-04 | 5.373120e-02 |
[] means no hidden layer, but there is still a linear output layer. This situation is equal to the linear regression.
Embedding net size tuning form on Al2O3: (Fitting-net size: [240,240,240])
Embedding-net size | Energy L2err(eV) | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|---|
[25,50,100] | 1.742252e-02 | 7.259383e-05 | 4.014115e-02 |
[10,20,40] | 2.909990e-02 | 1.212496e-04 | 4.734667e-02 |
[5,10,20] | 3.357767e-02 | 1.399070e-04 | 5.706385e-02 |
[4,8,16] | 6.060367e-02 | 2.525153e-04 | 7.333304e-02 |
[3,6,12] | 5.656043e-02 | 2.356685e-04 | 7.793539e-02 |
[2,4,8] | 5.277023e-02 | 2.198759e-04 | 7.459995e-02 |
[1,2,4] | 1.302282e-01 | 5.426174e-04 | 9.672238e-02 |
Cu
Fitting net size tuning form on Cu: (embedding-net size: [25,50,100])
Fitting-net size | Energy L2err(eV) | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|---|
[240,240,240] | 4.135548e-02 | 1.615449e-04 | 8.940946e-02 |
[20,20,20] | 4.323858e-02 | 1.689007e-04 | 8.955762e-02 |
[10,10,10] | 4.399364e-02 | 1.718502e-04 | 8.962891e-02 |
[5,5,5] | 4.468404e-02 | 1.745470e-04 | 8.970111e-02 |
[4,4,4] | 4.463580e-02 | 1.743586e-04 | 8.972011e-02 |
[3,3,3] | 4.493758e-02 | 1.755374e-04 | 8.971303e-02 |
[2,2,2] | 4.500736e-02 | 1.758100e-04 | 8.973878e-02 |
[1,1,1] | 4.542073e-02 | 1.774247e-04 | 8.964761e-02 |
[] | 4.545168e-02 | 1.775456e-04 | 8.983201e-02 |
Embedding net size tuning form on Cu: (Fitting-net size: [240,240,240])
Embedding-net size | Energy L2err(eV) | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|---|
[25,50,100] | 4.135548e-02 | 1.615449e-04 | 8.940946e-02 |
[20,40,80] | 4.203562e-02 | 1.642016e-04 | 8.925881e-02 |
[15,30,60] | 4.146672e-02 | 1.619794e-04 | 8.936911e-02 |
[10,20,40] | 4.263060e-02 | 1.665258e-04 | 8.955818e-02 |
[5,10,20] | 4.994913e-02 | 1.951138e-04 | 9.007786e-02 |
[4,8,16] | 1.022157e-01 | 3.992802e-04 | 9.532119e-02 |
[3,6,12] | 1.362098e-01 | 5.320695e-04 | 1.073860e-01 |
[2,4,8] | 7.061800e-02 | 2.758515e-04 | 9.126418e-02 |
[1,2,4] && seed = 1 | 9.843161e-02 | 3.844985e-04 | 9.348505e-02 |
[1,2,4] && seed = 2 | 9.404335e-02 | 3.673568e-04 | 9.304089e-02 |
[1,2,4] && seed = 3 | 1.508016e-01 | 5.890688e-04 | 1.382356e-01 |
[1,2,4] && seed = 4 | 9.686949e-02 | 3.783965e-04 | 9.294820e-02 |
Water
Fitting net size tuning form on water: (embedding-net size: [25,50,100])
Fitting-net size | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|
[240,240,240] | 9.1589E-04 | 5.1540E-02 |
[200,200,200] | 9.3221E-04 | 5.2366E-02 |
[160,160,160] | 9.4274E-04 | 5.3403E-02 |
[120,120,120] | 9.5407E-04 | 5.3093E-02 |
[80,80,80] | 9.4605E-04 | 5.3402E-02 |
[40,40,40] | 9.8533E-04 | 5.5790E-02 |
[20,20,20] | 1.0057E-03 | 5.8232E-02 |
[10,10,10] | 1.0466E-03 | 6.2279E-02 |
[5,5,5] | 1.1154E-03 | 6.7994E-02 |
[4,4,4] | 1.1289E-03 | 6.9613E-02 |
[3,3,3] | 1.2368E-03 | 7.9786E-02 |
[2,2,2] | 1.3558E-03 | 9.7042E-02 |
[1,1,1] | 1.4633E-03 | 1.1265E-01 |
[] | 1.5193E-03 | 1.2136E-01 |
Embedding net size tuning form on water: (Fitting-net size: [240,240,240])
Embedding-net size | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|
[25,50,100] | 9.1589E-04 | 5.1540E-02 |
[20,40,80] | 9.5080E-04 | 5.3593E-02 |
[15,30,60] | 9.7996E-04 | 5.6338E-02 |
[10,20,40] | 1.0353E-03 | 6.2776E-02 |
[5,10,20] | 1.1254E-03 | 7.3195E-02 |
[4,8,16] | 1.2495E-03 | 8.0371E-02 |
[3,6,12] | 1.3604E-03 | 9.9883E-02 |
[2,4,8] | 1.4358E-03 | 9.7389E-02 |
[1,2,4] | 2.1765E-03 | 1.7276E-01 |
Mg-Al
Fitting net size tuning form on Mg-Al: (embedding-net size: [25,50,100])
Fitting-net size | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|
[240,240,240] | 3.9606e-03 | 1.6289e-02 |
[200,200,200] | 3.9449e-03 | 1.6471e-02 |
[160,160,160] | 4.0947e-03 | 1.6413e-02 |
[120,120,120] | 3.9234e-03 | 1.6283e-02 |
[80,80,80] | 3.9758e-03 | 1.6506e-02 |
[40,40,40] | 3.9142e-03 | 1.6348e-02 |
[20,20,20] | 4.1302e-03 | 1.7006e-02 |
[10,10,10] | 4.3433e-03 | 1.7524e-02 |
[5,5,5] | 5.3154e-03 | 1.9716e-02 |
[4,4,4] | 5.4210e-03 | 1.9710e-02 |
[2,2,2] | 6.2667e-03 | 2.2568e-02 |
[1,1,1] | 7.3676e-03 | 2.6375e-02 |
[] | 7.3999e-03 | 2.6097e-02 |
Embedding net size tuning form on Mg-Al: (Fitting-net size: [240,240,240])
Embedding-net size | Energy L2err/Natoms(eV) | Force L2err(eV/Angstrom) |
|---|---|---|
[25,50,100] | 3.9606e-03 | 1.6289e-02 |
[20,40,80] | 4.0292e-03 | 1.6555e-02 |
[15,30,60] | 4.1743e-03 | 1.7026e-02 |
[10,20,40] | 4.8138e-03 | 1.8516e-02 |
[5,10,20] | 5.6052e-03 | 2.0709e-02 |
[4,8,16] | 6.1335e-03 | 2.1450e-02 |
[3,6,12] | 6.6469e-03 | 2.3003e-02 |
[2,4,8] | 6.8222e-03 | 2.6318e-02 |
[1,2,4] | 1.0678e-02 | 3.9559e-02 |
How to control the parallelism of a job?
DeePMD-kit has three levels of parallelism. To get the best performance, one should control the number of threads used by DeePMD-kit. One should make sure the product of the parallel numbers is less than or equal to the number of cores available.
MPI (optional)
Parallelism for MPI is optional and used for multiple nodes, multiple GPU cards, or sometimes multiple CPU cores.
To enable MPI support for training, one should install horovod in advance. Note that the parallelism mode is data parallelism, so it is not expected to see the training time per batch decreases.
MPI support for inference is not directly supported by DeePMD-kit, but indirectly supported by the third-party software. For example, LAMMPS enables running simulations in parallel using the MPI parallel communication standard with distributed data. That software has to build against MPI.
Set the number of processes with:
mpirun -np $num_nodes dp
Note that mpirun here should be the same as the MPI used to build software. For example, one can use mpirun -h and lmp -h to see if mpirun and LAMMPS has the same MPI version.
Sometimes, $num_nodes and the nodes information can be directly given by the HPC scheduler system, if the MPI used here is the same as the MPI used to build the scheduler system. Otherwise, one have to manually assign these information.
Parallelism between independent operators
For CPU devices, TensorFlow use multiple streams to run independent operators (OP).
export TF_INTER_OP_PARALLELISM_THREADS=3
However, for GPU devices, TensorFlow uses only one compute stream and multiple copy streams. Note that some of DeePMD-kit OPs do not have GPU support, so it is still encouraged to set environmental variables even if one has a GPU.
Parallelism within an individual operators
For CPU devices, TF_INTRA_OP_PARALLELISM_THREADS controls parallelism within TensorFlow native OPs when TensorFlow is built against Eigen.
export TF_INTRA_OP_PARALLELISM_THREADS=2
OMP_NUM_THREADS is threads for OpenMP parallelism. It controls parallelism within TensorFlow native OPs when TensorFlow is built by Intel OneDNN and DeePMD-kit custom CPU OPs. It may also control parallelsim for NumPy when NumPy is built against OpenMP, so one who uses GPUs for training should also care this environmental variable.
export OMP_NUM_THREADS=2
There are several other environmental variables for OpenMP, such as KMP_BLOCKTIME. See Intel documentation for detailed information.
Tune the performance
There is no one general parallel configuration that works for all situations, so you are encouraged to tune parallel configurations yourself after empirical testing.
Here are some empirical examples. If you wish to use 3 cores of 2 CPUs on one node, you may set the environmental variables and run DeePMD-kit as follows:
export OMP_NUM_THREADS=3
export TF_INTRA_OP_PARALLELISM_THREADS=3
export TF_INTER_OP_PARALLELISM_THREADS=2
dp train input.json
For a node with 128 cores, it is recommended to start with the following variables:
export OMP_NUM_THREADS=16
export TF_INTRA_OP_PARALLELISM_THREADS=16
export TF_INTER_OP_PARALLELISM_THREADS=8
Again, in general, one should make sure the product of the parallel numbers is less than or equal to the number of cores available. In the above case, \(16 \times 8 = 128\), so threads will not compete with each other.
Do we need to set rcut < half boxsize?
When seeking the neighbors of atom i under periodic boundary conditions, DeePMD-kit considers all j atoms within cutoff rcut from atom i in all mirror cells.
So, there is no limitation on the setting of rcut.
PS: The reason why some software requires rcut < half box size is that they only consider the nearest mirrors from the center cell. DeePMD-kit is different from them.
How to set sel?
sel is short for “selected number of atoms in rcut”.
sel_a[i] is a list of integers. The length of the list should be the same as the number of atom types in the system.
sel_a[i] gives the number of the selected number of type i neighbors within rcut. To ensure that the results are strictly accurate, sel_a[i] should be larger than the largest number of type i neighbors in the rcut.
However, the computation overhead increases with sel_a[i], therefore, sel_a[i] should be as small as possible.
The setting of sel_a[i] should balance the above two considerations.
Installation
Inadequate versions of gcc/g++
Sometimes you may use a gcc/g++ of version < 4.8. In this way, you can still compile all the parts of TensorFlow and most of the parts of DeePMD-kit, but i-Pi and GROMACS plugins will be disabled automatically. Or if you have a gcc/g++ of version > 4.8, say, 7.2.0, you may choose to use it by doing
export CC=/path/to/gcc-7.2.0/bin/gcc
export CXX=/path/to/gcc-7.2.0/bin/g++
Build files left in DeePMD-kit
When you try to build a second time when installing DeePMD-kit, files produced before may contribute to failure. Thus, you may clear them by
cd build
rm -r *
and redo the cmake process.
The temperature undulates violently during the early stages of MD
This is probably because your structure is too far from the equilibrium configuration.
To make sure the potential model is truly accurate, we recommend checking model deviation.
MD: cannot run LAMMPS after installing a new version of DeePMD-kit
This typically happens when you install a new version of DeePMD-kit and copy directly the generated USER-DEEPMD to a LAMMPS source code folder and re-install LAMMPS.
To solve this problem, it suffices to first remove USER-DEEPMD from the LAMMPS source code by
make no-user-deepmd
and then install the new USER-DEEPMD.
If this does not solve your problem, try to decompress the LAMMPS source tarball and install LAMMPS from scratch again, which typically should be very fast.
Model compatibility
When the version of DeePMD-kit used to train the model is different from the that of DeePMD-kit running MDs, one has the problem of model compatibility.
DeePMD-kit guarantees that the codes with the same major and minor revisions are compatible. That is to say, v0.12.5 is compatible with v0.12.0, but is not compatible with v0.11.0 or v1.0.0.
One can execute dp convert-from to convert an old model to a new one.
Model version | v0.12 | v1.0 | v1.1 | v1.2 | v1.3 | v2.0 | v2.1 |
|---|---|---|---|---|---|---|---|
Compatibility | 😊 | 😊 | 😊 | 😊 | 😊 | 😄 | 😄 |
Legend:
😄: The model is compatible with the DeePMD-kit package.
😊: The model is incompatible with the DeePMD-kit package, but one can execute
dp convert-fromto convert an old model to v2.1.😢: The model is incompatible with the DeePMD-kit package, and there is no way to convert models.
Why does a model have low precision?
Many phenomena are caused by model accuracy. For example, during simulations, temperatures explode, structures fall apart, and atoms are lost. One can test the model to confirm whether the model has the enough accuracy.
There are many reasons for a low-quality model. Some common reasons are listed below.
Data
Data units and signs
The unit of training data should follow what is listed in data section. Usually, the package to calculate the training data has different units from those of the DeePMD-kit. It is noted that some software label the energy gradient as forces, instead of the negative energy gradient. It is neccessary to check them carefully to avoid inconsistent data.
SCF coverage and data accuracy
The accuracy of models will not exceed the accuracy of training data, so the training data should reach enough accuracy. Here is a checklist for the accuracy of data:
SCF should converge to a suitable threshold for all points in the training data.
The convergence of the energy, force and virial with respect to the energy cutoff and k-spacing sample is checked.
Sometimes, QM software may generate unstable outliers, which should be removed.
The data should be extracted with enough digits and stored with the proper precision. Large energies may have low precision when they are stored as the single-precision floating-point format (FP32).
Enough data
If the model performs good on the training data, but has bad accuracy on another data, this means some data space is not covered by the training data. It can be validated by evaluting the model deviation with multiple models. If the model deviation of these data is high for some data, try to collect more data using DP-GEN.
Values of data
One should be aware that the errors of some data is also affected by the absolute values of this data. Stable structures tend to be more precise than unstable structures because unstable structures may have larger forces. Also, errors will be introduced in the Projector augmented wave (PAW) DFT calculations when the atoms are very close due to the overlap of pseudo-potentials. It is expected to see that data with large forces has larger errors and it is better to compare different models only with the same data.
Model
Enough sel
The sel of the descriptors must be enough for both training and test data. Otherwise, the model will be unreliable and give wrong results.
Cutoff radius
The model cannot fit the long-term interaction out of the cutoff radius. This is a designed approximation for performance, but one has to choose proper cutoff radius for the system.
Neural network size
The size of neural networks will affect the accuracy, but if one follows the parameters in the examples, this effect is insignificant. See FAQ: How to tune Fitting/embedding-net size for details.
Neural network precision
In some cases, one may want to use the FP32 precision to make the model faster. For some applications, FP32 is enough and thus is recommended, but one should still be aware that the precision of FP32 is not as high as that of FP64.
Training
Training steps
Generally speaking, the longer the number of training steps, the better the model. A balance between model accuracy and training time can be achieved. If one finds that model accuracy decreases with training time, there may be a problem with the data. See the data section for details.
Learning rate
Both too large and too small learning rate may affect the training. It is recommended to start with a large learning rate and end with a small learning rate. The learning rate from the examples is a good choice to start.
Find DeePMD-kit C/C++ library from CMake
After DeePMD-kit C/C++ library is installed, one can find DeePMD-kit from CMake:
find_package(DeePMD REQUIRED)
Note that you may need to add ${deepmd_root} to the cached CMake variable CMAKE_PREFIX_PATH.
To link against the C interface library, using
target_link_libraries(some_library PRIVATE DeePMD::deepmd_c)
To link against the C++ interface library, using
target_link_libraries(some_library PRIVATE DeePMD::deepmd_cc)
Coding Conventions
Preface
The aim of these coding standards is to help create a codebase with a defined and consistent coding style that every contributor can get easily familiar with. This will in enhance code readability as there will be no different coding styles from different contributors and everything will be documented. Also, PR diffs will be smaller because of the unified coding style. Finally, static typing will help in hunting down potential bugs before the code is even run.
Contributed code will not be refused merely because it does not strictly adhere to these conditions; as long as it’s internally consistent, clean, and correct, it probably will be accepted. But don’t be surprised if the “offending” code gets fiddled with overtime to conform to these conventions.
There are also GitHub actions CI checks for python code style which will annotate the PR diff for you to see the areas where your code is lacking compared to the set standard.
Rules
The code must be compatible with the oldest supported version of python which is 3.7
The project follows the generic coding conventions as specified in the Style Guide for Python Code, Docstring Conventions and Typing Conventions PEPs, clarified and extended as follows:
Do not use “
*” imports such asfrom module import *. Instead, list imports explicitly.Use 4 spaces per indentation level. No tabs.
No one-liner compound statements (i.e., no
if x: return: use two lines).Maximum line length is 88 characters as recommended by black which is less strict than Docstring Conventions suggests.
Use “StudlyCaps” for class names.
Use “lowercase” or “lowercase_with_underscores” for function, method, variable names and module names. For short names, joined lowercase may be used (e.g. “tagname”). Choose what is most readable.
No single-character variable names, except indices in loops that encompass a very small number of lines (
for i in range(5): ...).Avoid lambda expressions. Use named functions instead.
Avoid functional constructs (filter, map, etc.). Use list comprehensions instead.
Use
"double quotes"for string literals, and"""triple double quotes"""for docstring’s. Single quotes are OK for something likef"something {'this' if x else 'that'}"
Use f-strings
s = f"{x:.2f}"instead of old style formating with"%f" % x. string format method"{x:.2f}".format()may be used sparsely where it is more convenient than f-strings.
Whitespace
Python is not C/C++ so whitespace should be used sparingly to maintain code readability
Read the Whitespace in Expressions and Statements section of PEP8.
Avoid trailing whitespaces.
Do not use excessive whitespace in your expressions and statements.
You should have blank spaces after commas, colons, and semi-colons if it isn’t trailing next to the end of a bracket, brace, or parentheses.
With any operators you should use space on both sides of the operator.
Colons for slicing are considered a binary operator, and should not have any spaces between them.
You should have parentheses with no space, directly next to the function when calling functions
function().When indexing or slicing the brackets should be directly next to the collection with no space
collection["index"].Whitespace used to line up variable values is not recommended.
Make sure you are consistent with the formats you choose when optional choices are available.
General advice
Get rid of as many
breakandcontinuestatements as possible.Write short functions. All functions should fit within a standard screen.
Use descriptive variable names.
Writing documentation in the code
Here is an example of how to write good docstrings:
The NumPy docstring documentation can be found here
It is a good practice to run pydocstyle check on your code or use a text editor that does it automatically):
$ pydocstyle filename.py
Run pycodestyle on your code
It’s a good idea to run pycodestyle on your code (or use a text editor that does it automatically):
$ pycodestyle filename.py
Run mypy on your code
It’s a good idea to run mypy on your code (or use a text editor that does it automatically):
$ mypy filename.py
Run pydocstyle on your code
It’s a good idea to run pycodestyle on your code (or use a text editor that does it automatically):
$ pycodestyle filename.py --max-line-length=88
Run black on your code
Another method of enforcing PEP8 is using a tool such as black. These tools tend to be very effective at cleaning up code but should be used carefully and code should be retested after cleaning it. Try:
$ black --help
Create a model
If you’d like to create a new model that isn’t covered by the existing DeePMD-kit library, but reuse DeePMD-kit’s other efficient modules such as data processing, trainner, etc, you may want to read this section.
To incorporate your custom model you’ll need to:
Register and implement new components (e.g. descriptor) in a Python file. You may also want to register new TensorFlow OPs if necessary.
Register new arguments for user inputs.
Package new codes into a Python package.
Test new models.
Design a new component
When creating a new component, take descriptor as the example, you should inherit deepmd.descriptor.descriptor.Descriptor class and override several methods. Abstract methods such as deepmd.descriptor.descriptor.Descriptor.build must be implemented and others are not. You should keep arguments of these methods unchanged.
After implementation, you need to register the component with a key:
from deepmd.descriptor import Descriptor
@Descriptor.register("some_descrpt")
class SomeDescript(Descriptor):
def __init__(self, arg1: bool, arg2: float) -> None:
pass
Register new arguments
To let someone uses your new component in their input file, you need to create a new method that returns some Argument of your new component, and then register new arguments. For example, the code below
from typing import List
from dargs import Argument
from deepmd.utils.argcheck import descrpt_args_plugin
@descrpt_args_plugin.register("some_descrpt")
def descrpt_some_args() -> List[Argument]:
return [
Argument("arg1", bool, optional=False, doc="balabala"),
Argument("arg2", float, optional=True, default=6.0, doc="haha"),
]
allows one to use your new descriptor as below:
"descriptor" :{
"type": "some_descrpt",
"arg1": true,
"arg2": 6.0
}
The arguments here should be consistent with the class arguments of your new component.
Package new codes
You may use setuptools to package new codes into a new Python package. It’s crucial to add your new component to entry_points['deepmd'] in setup.py:
entry_points={
'deepmd': [
'some_descrpt=deepmd_some_descrtpt:SomeDescript',
],
},
where deepmd_some_descrtpt is the module of your codes. It is equivalent to from deepmd_some_descrtpt import SomeDescript.
If you place SomeDescript and descrpt_some_args into different modules, you are also expected to add descrpt_some_args to entry_points.
After you install your new package, you can now use dp train to run your new model.
Atom Type Embedding
Overview
Here is an overview of the DeePMD-kit algorithm. Given a specific centric atom, we can obtain the matrix describing its local environment, named \(\mathcal R\). It is consist of the distance between the centric atom and its neighbors, as well as a direction vector. We can embed each distance into a vector of \(M_1\) dimension by an embedding net, so the environment matrix \(\mathcal R\) can be embedded into matrix \(\mathcal G\). We can thus extract a descriptor vector (of \(M_1 \times M_2\) dim) of the centric atom from the \(\mathcal G\) by some matrix multiplication, and put the descriptor into fitting net to get predicted energy \(E\). The vanilla version of DeePMD-kit builds embedding net and fitting net relying on the atom type, resulting in \(O(N)\) memory usage. After applying atom type embedding, in DeePMD-kit v2.0, we can share one embedding net and one fitting net in total, which decline training complexity largely.
Preliminary
In the following chart, you can find the meaning of symbols used to clarify the atom-type embedding algorithm.
\(i\): Type of centric atom
\(j\): Type of neighbor atom
\(s_{ij}\): Distance between centric atom and neighbor atom
\(\mathcal G_{ij}(\cdot)\): Origin embedding net, take \(s_{ij}\) as input and output embedding vector of \(M_1\) dim
\(\mathcal G(\cdot)\): Shared embedding net
\(\text{Multi}(\cdot)\): Matrix multiplication and flattening, output the descriptor vector of \(M_1\times M_2\) dim
\(F_i(\cdot)\): Origin fitting net, take the descriptor vector as input and output energy
\(F(\cdot)\): Shared fitting net
\(A(\cdot)\): Atom type embedding net, input is atom type, the output is type embedding vector of dim nchanl
So, we can formulate the training process as follows. Vanilla DeePMD-kit algorithm:
DeePMD-kit applying atom type embedding:
or
The difference between the two variants above is whether using the information of centric atom when generating the descriptor. Users can choose by modifying the type_one_side hyper-parameter in the input JSON file.
How to use
A detailed introduction can be found at se_e2_a_tebd. Looking for a fast start-up, you can simply add a type_embedding section in the input JSON file as displayed in the following, and the algorithm will adopt the atom type embedding algorithm automatically. An example of type_embedding is like
"type_embedding":{
"neuron": [2, 4, 8],
"resnet_dt": false,
"seed": 1
}
Code Modification
Atom-type embedding can be applied to varied embedding net and fitting net, as a result, we build a class TypeEmbedNet to support this free combination. In the following, we will go through the execution process of the code to explain our code modification.
trainer (train/trainer.py)
In trainer.py, it will parse the parameter from the input JSON file. If a type_embedding section is detected, it will build a TypeEmbedNet, which will be later input in the model. model will be built in the function _build_network.
model (model/ener.py)
When building the operation graph of the model in model.build. If a TypeEmbedNet is detected, it will build the operation graph of type embed net, embedding net and fitting net by order. The building process of type embed net can be found in TypeEmbedNet.build, which output the type embedding vector of each atom type (of [\(\text{ntypes} \times \text{nchanl}\)] dimensions). We then save the type embedding vector into input_dict, so that they can be fetched later in embedding net and fitting net.
embedding net (descriptor/se*.py)
In embedding net, we shall take local environment \(\mathcal R\) as input and output matrix \(\mathcal G\). Functions called in this process by the order is
build -> _pass_filter -> _filter -> _filter_lower
_pass_filter: It will first detect whether an atom type embedding exists, if so, it will apply atom type embedding algorithm and doesn’t divide the input by type.
_filter: It will call _filter_lower function to obtain the result of matrix multiplication (\(\mathcal G^T\cdot \mathcal R\)), do further multiplication involved in \(\text{Multi}(\cdot)\), and finally output the result of descriptor vector of \(M_1 \times M_2\) dim.
_filter_lower: The main function handling input modification. If type embedding exists, it will call _concat_type_embedding function to concat the first column of input \(\mathcal R\) (the column of \(s_{ij}\)) with the atom type embedding information. It will decide whether to use the atom type embedding vector of the centric atom according to the value of type_one_side (if set True, then we only use the vector of the neighbor atom). The modified input will be put into the fitting net to get \(\mathcal G\) for further matrix multiplication stage.
fitting net (fit/ener.py)
In fitting net, it takes the descriptor vector as input, whose dimension is [natoms, \(M_1\times M_2\)]. Because we need to involve information on the centric atom in this step, we need to generate a matrix named atype_embed (of dim [natoms, nchanl]), in which each row is the type embedding vector of the specific centric atom. The input is sorted by type of centric atom, we also know the number of a particular atom type (stored in natoms[2+i]), thus we get the type vector of the centric atom. In the build phase of the fitting net, it will check whether type embedding exists in input_dict and fetch them. After that, call embed_atom_type function to look up the embedding vector for the type vector of the centric atom to obtain atype_embed, and concat input with it ([input, atype_embed]). The modified input goes through fitting net` to get predicted energy.
Note
You can’t apply the compression method while using atom-type embedding.
Python API
deepmd package
Root of the deepmd package, exposes all public classes and submodules.
- class deepmd.DeepEval(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False, auto_batch_size: Union[bool, int, deepmd.utils.batch_size.AutoBatchSize] = False)[source]
Bases:
objectCommon methods for DeepPot, DeepWFC, DeepPolar, …
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- auto_batch_sizebool or
intorAutomaticBatchSize, default:False If True, automatic batch size will be used. If int, it will be used as the initial batch size.
- model_file
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- make_natoms_vec(atom_types: numpy.ndarray, mixed_type: bool = False) numpy.ndarray[source]
Make the natom vector used by deepmd-kit.
- Parameters
- atom_types
The type of atoms
- 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.
- Returns
natomsThe 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
- static reverse_map(vec: numpy.ndarray, imap: List[int]) numpy.ndarray[source]
Reverse mapping of a vector according to the index map
- Parameters
- vec
Input vector. Be of shape [nframes, natoms, -1]
- imap
Index map. Be of shape [natoms]
- Returns
vec_outReverse mapped vector.
- property sess: tensorflow.python.client.session.Session
Get TF session.
- static sort_input(coord: numpy.ndarray, atom_type: numpy.ndarray, sel_atoms: Optional[List[int]] = None, mixed_type: bool = False)[source]
Sort atoms in the system according their types.
- Parameters
- coord
The coordinates of atoms. Should be of shape [nframes, natoms, 3]
- atom_type
The type of atoms Should be of shape [natoms]
- sel_atoms
The selected atoms by type
- 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.
- Returns
coord_outThe coordinates after sorting
atom_type_outThe atom types after sorting
idx_mapThe index mapping from the input to the output. For example coord_out = coord[:,idx_map,:]
sel_atom_typeOnly output if sel_atoms is not None The sorted selected atom types
sel_idx_mapOnly output if sel_atoms is not None The index mapping from the selected atoms to sorted selected atoms.
- deepmd.DeepPotential(model_file: Union[str, pathlib.Path], load_prefix: str = 'load', default_tf_graph: bool = False) Union[deepmd.infer.deep_dipole.DeepDipole, deepmd.infer.deep_polar.DeepGlobalPolar, deepmd.infer.deep_polar.DeepPolar, deepmd.infer.deep_pot.DeepPot, deepmd.infer.deep_wfc.DeepWFC][source]
Factory function that will inialize appropriate potential read from model_file.
- Parameters
- model_file: str
The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- Returns
Union[DeepDipole,DeepGlobalPolar,DeepPolar,DeepPot,DeepWFC]one of the available potentials
- Raises
RuntimeErrorif model file does not correspond to any implementd potential
- class deepmd.DipoleChargeModifier(model_name: str, model_charge_map: List[float], sys_charge_map: List[float], ewald_h: float = 1, ewald_beta: float = 1)[source]
Bases:
deepmd.infer.deep_dipole.DeepDipole- Parameters
- model_name
The model file for the DeepDipole model
- model_charge_map
Gives the amount of charge for the wfcc
- sys_charge_map
Gives the amount of charge for the real atoms
- ewald_h
Grid spacing of the reciprocal part of Ewald sum. Unit: A
- ewald_beta
Splitting parameter of the Ewald sum. Unit: A^{-1}
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
Build the computational graph for the force and virial inference.
eval(coord, box, atype[, eval_fv])Evaluate the modification
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
get_dim_aparam()Unsupported in this model.
get_dim_fparam()Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
modify_data(data)Modify data.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- build_fv_graph() tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the force and virial inference.
- eval(coord: numpy.ndarray, box: numpy.ndarray, atype: numpy.ndarray, eval_fv: bool = True) Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray][source]
Evaluate the modification
- Parameters
- coord
The coordinates of atoms
- box
The simulation region. PBC is assumed
- atype
The atom types
- eval_fv
Evaluate force and virial
- Returns
tot_eThe energy modification
tot_fThe force modification
tot_vThe virial modification
- modify_data(data: dict) None[source]
Modify data.
- Parameters
- data
Internal data of DeepmdData. Be a dict, has the following keys - coord coordinates - box simulation box - type atom types - find_energy tells if data has energy - find_force tells if data has force - find_virial tells if data has virial - energy energy - force force - virial virial
Subpackages
deepmd.cluster package
Module that reads node resources, auto detects if running local or on SLURM.
- deepmd.cluster.get_resource() Tuple[str, List[str], Optional[List[int]]][source]
Get local or slurm resources: nodename, nodelist, and gpus.
Submodules
deepmd.cluster.local module
Get local GPU resources.
deepmd.cluster.slurm module
MOdule to get resources on SLURM cluster.
https://github.com/deepsense-ai/tensorflow_on_slurm ####
- deepmd.cluster.slurm.get_resource() Tuple[str, List[str], Optional[List[int]]][source]
Get SLURM resources: nodename, nodelist, and gpus.
- Returns
- Raises
RuntimeErrorif number of nodes could not be retrieved
ValueErrorlist of nodes is not of the same length sa number of nodes
ValueErrorif current nodename is not found in node list
deepmd.descriptor package
Submodules
deepmd.descriptor.descriptor module
- class deepmd.descriptor.descriptor.Descriptor(*args, **kwargs)[source]
Bases:
deepmd.utils.plugin.PluginVariantThe abstract class for descriptors. All specific descriptors should be based on this class.
The descriptor \(\mathcal{D}\) describes the environment of an atom, which should be a function of coordinates and types of its neighbour atoms.
Notes
Only methods and attributes defined in this class are generally public, that can be called by other classes.
Examples
>>> descript = Descriptor(type="se_e2_a", rcut=6., rcut_smth=0.5, sel=[50]) >>> type(descript) <class 'deepmd.descriptor.se_a.DescrptSeA'>
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor.
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor.
Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
Returns neighbor information.
Returns the number of atom types.
get_rcut()Returns the cut-off radius.
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
pass_tensors_from_frz_model(*tensors)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial.
register(key)Regiester a descriptor plugin.
- abstract build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: Dict[str, Any], reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor.
- Parameters
- coord_
tf.Tensor The coordinate of atoms
- atype_
tf.Tensor The type of atoms
- natoms
tf.Tensor 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
- box
tf.Tensor The box of frames
- mesh
tf.Tensor For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
dict[str,Any] Dictionary for additional inputs
- reusebool,
optional The weights in the networks should be reused when get the variable.
- suffix
str,optional Name suffix to identify this descriptor
- coord_
- Returns
- descriptor:
tf.Tensor The output descriptor
- descriptor:
Notes
This method must be implemented, as it’s called by other classes.
- build_type_exclude_mask(exclude_types: List[Tuple[int, int]], ntypes: int, sel: List[int], ndescrpt: int, atype: tensorflow.python.framework.ops.Tensor, shape0: tensorflow.python.framework.ops.Tensor) tensorflow.python.framework.ops.Tensor[source]
Build the type exclude mask for the descriptor.
- Parameters
- exclude_types
List[Tuple[int,int]] The list of excluded types, e.g. [(0, 1), (1, 0)] means the interaction between type 0 and type 1 is excluded.
- ntypes
int The number of types.
- sel
List[int] The list of the number of selected neighbors for each type.
- ndescrpt
int The number of descriptors for each atom.
- atype
tf.Tensor The type of atoms, with the size of shape0.
- shape0
tf.Tensor The shape of the first dimension of the inputs, which is equal to nsamples * natoms.
- exclude_types
- Returns
tf.TensorThe type exclude mask, with the shape of (shape0, ndescrpt), and the precision of GLOBAL_TF_FLOAT_PRECISION. The mask has the value of 1 if the interaction between two types is not excluded, and 0 otherwise.
Notes
To exclude the interaction between two types, the derivative of energy with respect to distances (or angles) between two atoms should be zero[Rafc1ae60e195-1]_, i.e.
\[\forall i \in \text{type 1}, j \in \text{type 2}, \frac{\partial{E}}{\partial{r_{ij}}} = 0\]When embedding networks between every two types are built, we can just remove that network. But when type_one_side is enabled, a network may be built for multiple pairs of types. In this case, we need to build a mask to exclude the interaction between two types.
The mask assumes the descriptors are sorted by neighbro type with the fixed number of given sel and each neighbor has the same number of descriptors (for example 4).
References
- 1
Jinzhe Zeng, Timothy J. Giese, ̧Sölen Ekesan, Darrin M. York, Development of Range-Corrected Deep Learning Potentials for Fast, Accurate Quantum Mechanical/molecular Mechanical Simulations of Chemical Reactions in Solution, J. Chem. Theory Comput., 2021, 17 (11), 6993-7009.
- abstract compute_input_stats(data_coord: List[numpy.ndarray], data_box: List[numpy.ndarray], data_atype: List[numpy.ndarray], natoms_vec: List[numpy.ndarray], mesh: List[numpy.ndarray], input_dict: Dict[str, List[numpy.ndarray]]) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
list[np.ndarray] The coordinates. Can be generated by
deepmd.model.model_stat.make_stat_input()- data_box
list[np.ndarray] The box. Can be generated by
deepmd.model.model_stat.make_stat_input()- data_atype
list[np.ndarray] The atom types. Can be generated by
deepmd.model.model_stat.make_stat_input()- natoms_vec
list[np.ndarray] The vector for the number of atoms of the system and different types of atoms. Can be generated by
deepmd.model.model_stat.make_stat_input()- mesh
list[np.ndarray] The mesh for neighbor searching. Can be generated by
deepmd.model.model_stat.make_stat_input()- input_dict
dict[str,list[np.ndarray]] Dictionary for additional input
- data_coord
Notes
This method must be implemented, as it’s called by other classes.
- enable_compression(min_nbor_dist: float, graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, table_extrapolate: float = 5.0, table_stride_1: float = 0.01, table_stride_2: float = 0.1, check_frequency: int = - 1, suffix: str = '') None[source]
Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
- Parameters
- min_nbor_dist
float The nearest distance between atoms
- graph
tf.Graph The graph of the model
- graph_def
tf.GraphDef The graph definition of the model
- table_extrapolate
float, default: 5. The scale of model extrapolation
- table_stride_1
float, default: 0.01 The uniform stride of the first table
- table_stride_2
float, default: 0.1 The uniform stride of the second table
- check_frequency
int, default: -1 The overflow check frequency
- suffix
str,optional The suffix of the scope
- min_nbor_dist
Notes
This method is called by others when the descriptor supported compression.
- 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
Notes
This method is called by others when the descriptor supported compression.
- abstract get_dim_out() int[source]
Returns the output dimension of this descriptor.
- Returns
intthe output dimension of this descriptor
Notes
This method must be implemented, as it’s called by other classes.
- get_dim_rot_mat_1() int[source]
Returns the first dimension of the rotation matrix. The rotation is of shape dim_1 x 3
- Returns
intthe first dimension of the rotation matrix
- get_feed_dict(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor) Dict[str, tensorflow.python.framework.ops.Tensor][source]
Generate the feed_dict for current descriptor
- Parameters
- coord_
tf.Tensor The coordinate of atoms
- atype_
tf.Tensor The type of atoms
- natoms
tf.Tensor 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
- box
tf.Tensor The box. Can be generated by deepmd.model.make_stat_input
- mesh
tf.Tensor For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- coord_
- Returns
- get_nlist() Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
Returns neighbor information.
- abstract get_ntypes() int[source]
Returns the number of atom types.
- Returns
intthe number of atom types
Notes
This method must be implemented, as it’s called by other classes.
- abstract get_rcut() float[source]
Returns the cut-off radius.
- Returns
floatthe cut-off radius
Notes
This method must be implemented, as it’s called by other classes.
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') None[source]
Init the embedding net variables with the given dict
- Parameters
Notes
This method is called by others when the descriptor supported initialization from the given variables.
- pass_tensors_from_frz_model(*tensors: tensorflow.python.framework.ops.Tensor) None[source]
Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
- Parameters
- *tensors
tf.Tensor passed tensors
- *tensors
Notes
The number of parameters in the method must be equal to the numbers of returns in
get_tensor_names().
- abstract prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial.
- Parameters
- Returns
- static register(key: str) deepmd.descriptor.descriptor.Descriptor[source]
Regiester a descriptor plugin.
- Parameters
- key
str the key of a descriptor
- key
- Returns
Descriptorthe regiestered descriptor
Examples
>>> @Descriptor.register("some_descrpt") class SomeDescript(Descriptor): pass
deepmd.descriptor.hybrid module
- class deepmd.descriptor.hybrid.DescrptHybrid(*args, **kwargs)[source]
Bases:
deepmd.descriptor.descriptor.DescriptorConcate a list of descriptors to form a new descriptor.
- Parameters
- list
list Build a descriptor from the concatenation of the list of descriptors.
- list
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
get_nlist()Returns neighbor information.
get_nlist_i(ii)Get the neighbor information of the ii-th descriptor
Returns the number of atom types
get_rcut()Returns the cut-off radius
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(*tensors)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- enable_compression(min_nbor_dist: float, graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, table_extrapolate: float = 5.0, table_stride_1: float = 0.01, table_stride_2: float = 0.1, check_frequency: int = - 1, suffix: str = '') None[source]
Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
- Parameters
- min_nbor_dist
float The nearest distance between atoms
- graph
tf.Graph The graph of the model
- graph_def
tf.GraphDef The graph_def of the model
- table_extrapolate
float, default: 5. The scale of model extrapolation
- table_stride_1
float, default: 0.01 The uniform stride of the first table
- table_stride_2
float, default: 0.1 The uniform stride of the second table
- check_frequency
int, default: -1 The overflow check frequency
- suffix
str,optional The suffix of the scope
- min_nbor_dist
- enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]
Reveive the mixed precision setting.
- Parameters
- mixed_prec
The mixed precision setting used in the embedding net
- get_nlist_i(ii: int) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
Get the neighbor information of the ii-th descriptor
- Parameters
- ii
int The index of the descriptor
- ii
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') None[source]
Init the embedding net variables with the given dict
- merge_input_stats(stat_dict)[source]
Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
- Parameters
- stat_dict
The dict of statisitcs computed from compute_input_stats, including:
- sumr
The sum of radial statisitcs.
- suma
The sum of relative coord statisitcs.
- sumn
The sum of neighbor numbers.
- sumr2
The sum of square of radial statisitcs.
- suma2
The sum of square of relative coord statisitcs.
- pass_tensors_from_frz_model(*tensors: tensorflow.python.framework.ops.Tensor) None[source]
Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
- Parameters
- *tensors
tf.Tensor passed tensors
- *tensors
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
deepmd.descriptor.loc_frame module
- class deepmd.descriptor.loc_frame.DescrptLocFrame(*args, **kwargs)[source]
Bases:
deepmd.descriptor.descriptor.DescriptorDefines a local frame at each atom, and the compute the descriptor as local coordinates under this frame.
- Parameters
- rcut
The cut-off radius
- sel_a
list[str] The length of the list should be the same as the number of atom types in the system. sel_a[i] gives the selected number of type-i neighbors. The full relative coordinates of the neighbors are used by the descriptor.
- sel_r
list[str] The length of the list should be the same as the number of atom types in the system. sel_r[i] gives the selected number of type-i neighbors. Only relative distance of the neighbors are used by the descriptor. sel_a[i] + sel_r[i] is recommended to be larger than the maximally possible number of type-i neighbors in the cut-off radius.
- axis_rule: list[int]
The length should be 6 times of the number of types. - axis_rule[i*6+0]: class of the atom defining the first axis of type-i atom. 0 for neighbors with full coordinates and 1 for neighbors only with relative distance.
axis_rule[i*6+1]: type of the atom defining the first axis of type-i atom.
axis_rule[i*6+2]: index of the axis atom defining the first axis. Note that the neighbors with the same class and type are sorted according to their relative distance.
axis_rule[i*6+3]: class of the atom defining the second axis of type-i atom. 0 for neighbors with full coordinates and 1 for neighbors only with relative distance.
axis_rule[i*6+4]: type of the atom defining the second axis of type-i atom.
axis_rule[i*6+5]: index of the axis atom defining the second axis. Note that the neighbors with the same class and type are sorted according to their relative distance.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
- Returns
Returns the number of atom types
get_rcut()Returns the cut-off radius
Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
pass_tensors_from_frz_model(*tensors)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- get_nlist() Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') None[source]
Init the embedding net variables with the given dict
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
deepmd.descriptor.se module
- class deepmd.descriptor.se.DescrptSe(*args, **kwargs)[source]
Bases:
deepmd.descriptor.descriptor.DescriptorA base class for smooth version of descriptors.
Notes
All of these descriptors have an environmental matrix and an embedding network (
deepmd.utils.network.embedding_net()), so they can share some similiar methods without defining them twice.- Attributes
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor.
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
get_dim_out()Returns the output dimension of this descriptor.
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
get_nlist()Returns neighbor information.
get_ntypes()Returns the number of atom types.
get_rcut()Returns the cut-off radius.
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial.
register(key)Regiester a descriptor plugin.
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') None[source]
Init the embedding net variables with the given dict
- pass_tensors_from_frz_model(descrpt_reshape: tensorflow.python.framework.ops.Tensor, descrpt_deriv: tensorflow.python.framework.ops.Tensor, rij: tensorflow.python.framework.ops.Tensor, nlist: tensorflow.python.framework.ops.Tensor)[source]
Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
- Parameters
- descrpt_reshape
The passed descrpt_reshape tensor
- descrpt_deriv
The passed descrpt_deriv tensor
- rij
The passed rij tensor
- nlist
The passed nlist tensor
- property precision: tensorflow.python.framework.dtypes.DType
Precision of filter network.
deepmd.descriptor.se_a module
- class deepmd.descriptor.se_a.DescrptSeA(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se.DescrptSeDeepPot-SE constructed from all information (both angular and radial) of atomic configurations. The embedding takes the distance between atoms as input.
The descriptor \(\mathcal{D}^i \in \mathcal{R}^{M_1 \times M_2}\) is given by [1]
\[\mathcal{D}^i = (\mathcal{G}^i)^T \mathcal{R}^i (\mathcal{R}^i)^T \mathcal{G}^i_<\]where \(\mathcal{R}^i \in \mathbb{R}^{N \times 4}\) is the coordinate matrix, and each row of \(\mathcal{R}^i\) can be constructed as follows
\[(\mathcal{R}^i)_j = [ \begin{array}{c} s(r_{ji}) & \frac{s(r_{ji})x_{ji}}{r_{ji}} & \frac{s(r_{ji})y_{ji}}{r_{ji}} & \frac{s(r_{ji})z_{ji}}{r_{ji}} \end{array} ]\]where \(\mathbf{R}_{ji}=\mathbf{R}_j-\mathbf{R}_i = (x_{ji}, y_{ji}, z_{ji})\) is the relative coordinate and \(r_{ji}=\lVert \mathbf{R}_{ji} \lVert\) is its norm. The switching function \(s(r)\) is defined as:
\[\begin{split}s(r)= \begin{cases} \frac{1}{r}, & r<r_s \\ \frac{1}{r} \{ {(\frac{r - r_s}{ r_c - r_s})}^3 (-6 {(\frac{r - r_s}{ r_c - r_s})}^2 +15 \frac{r - r_s}{ r_c - r_s} -10) +1 \}, & r_s \leq r<r_c \\ 0, & r \geq r_c \end{cases}\end{split}\]Each row of the embedding matrix \(\mathcal{G}^i \in \mathbb{R}^{N \times M_1}\) consists of outputs of a embedding network \(\mathcal{N}\) of \(s(r_{ji})\):
\[(\mathcal{G}^i)_j = \mathcal{N}(s(r_{ji}))\]\(\mathcal{G}^i_< \in \mathbb{R}^{N \times M_2}\) takes first \(M_2\) columns of \(\mathcal{G}^i\). The equation of embedding network \(\mathcal{N}\) can be found at
deepmd.utils.network.embedding_net().- Parameters
- rcut
The cut-off radius \(r_c\)
- rcut_smth
From where the environment matrix should be smoothed \(r_s\)
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
- axis_neuron
Number of the axis neuron \(M_2\) (number of columns of the sub-matrix of the embedding matrix)
- resnet_dt
Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- type_one_side
Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- exclude_types
List[List[int]] 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.
- set_davg_zero
Set the shift of embedding net input to zero.
- activation_function
The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”.
- 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
- multi_task
If the model has multi fitting nets to train.
References
- 1(1,2)
Linfeng Zhang, Jiequn Han, Han Wang, Wissam A. Saidi, Roberto Car, and E. Weinan. 2018. End-to-end symmetry preserving inter-atomic potential energy model for finite and extended systems. In Proceedings of the 32nd International Conference on Neural Information Processing Systems (NIPS’18). Curran Associates Inc., Red Hook, NY, USA, 4441–4451.
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
- Returns
Returns the number of atom types
get_rcut()Returns the cut-off radius
Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- enable_compression(min_nbor_dist: float, graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, table_extrapolate: float = 5, table_stride_1: float = 0.01, table_stride_2: float = 0.1, check_frequency: int = - 1, suffix: str = '') None[source]
Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
- Parameters
- min_nbor_dist
The nearest distance between atoms
- grapf
tf.Graph The graph of the model
- graph_def
tf.GraphDef The graph_def of the model
- table_extrapolate
The scale of model extrapolation
- table_stride_1
The uniform stride of the first table
- table_stride_2
The uniform stride of the second table
- check_frequency
The overflow check frequency
- suffix
str,optional The suffix of the scope
- enable_mixed_precision(mixed_prec: Optional[dict] = None) None[source]
Reveive the mixed precision setting.
- Parameters
- mixed_prec
The mixed precision setting used in the embedding net
- get_dim_rot_mat_1() int[source]
Returns the first dimension of the rotation matrix. The rotation is of shape dim_1 x 3
- get_nlist() Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') None[source]
Init the embedding net variables with the given dict
- merge_input_stats(stat_dict)[source]
Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
- Parameters
- stat_dict
The dict of statisitcs computed from compute_input_stats, including:
- sumr
The sum of radial statisitcs.
- suma
The sum of relative coord statisitcs.
- sumn
The sum of neighbor numbers.
- sumr2
The sum of square of radial statisitcs.
- suma2
The sum of square of relative coord statisitcs.
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
deepmd.descriptor.se_a_ebd module
- class deepmd.descriptor.se_a_ebd.DescrptSeAEbd(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se_a.DescrptSeADeepPot-SE descriptor with type embedding approach.
- Parameters
- rcut
The cut-off radius
- rcut_smth
From where the environment matrix should be smoothed
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] Number of neurons in each hidden layers of the embedding net
- axis_neuron
Number of the axis neuron (number of columns of the sub-matrix of the embedding matrix)
- resnet_dt
Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- type_one_side
Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- type_nchanl
Number of channels for type representation
- type_nlayer
Number of hidden layers for the type embedding net (skip connected).
- numb_aparam
Number of atomic parameters. If >0 it will be embedded with atom types.
- set_davg_zero
Set the shift of embedding net input to zero.
- activation_function
The activation function in the embedding net. Supported options are {0}
- precision
The precision of the embedding net parameters. Supported options are {1}
- exclude_types
List[List[int]] 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.
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
get_dim_out()Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
get_nlist()- Returns
get_ntypes()Returns the number of atom types
get_rcut()Returns the cut-off radius
get_rot_mat()Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
deepmd.descriptor.se_a_ef module
- class deepmd.descriptor.se_a_ef.DescrptSeAEf(*args, **kwargs)[source]
Bases:
deepmd.descriptor.descriptor.Descriptor- Parameters
- rcut
The cut-off radius
- rcut_smth
From where the environment matrix should be smoothed
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] Number of neurons in each hidden layers of the embedding net
- axis_neuron
Number of the axis neuron (number of columns of the sub-matrix of the embedding matrix)
- resnet_dt
Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- type_one_side
Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- exclude_types
List[List[int]] 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.
- set_davg_zero
Set the shift of embedding net input to zero.
- activation_function
The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”.
- 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
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
- Returns
Returns the number of atom types
get_rcut()Returns the cut-off radius
Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
pass_tensors_from_frz_model(*tensors)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs. Should have ‘efield’.
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- get_dim_rot_mat_1() int[source]
Returns the first dimension of the rotation matrix. The rotation is of shape dim_1 x 3
- get_nlist() Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
- class deepmd.descriptor.se_a_ef.DescrptSeAEfLower(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se_a.DescrptSeAHelper class for implementing DescrptSeAEf
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
get_dim_out()Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
get_nlist()- Returns
get_ntypes()Returns the number of atom types
get_rcut()Returns the cut-off radius
get_rot_mat()Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_, atype_, natoms, box_, mesh, input_dict, suffix='', reuse=None)[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord, data_box, data_atype, natoms_vec, mesh, input_dict)[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
deepmd.descriptor.se_atten module
- class deepmd.descriptor.se_atten.DescrptSeAtten(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se_a.DescrptSeA- Parameters
- rcut
The cut-off radius \(r_c\)
- rcut_smth
From where the environment matrix should be smoothed \(r_s\)
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
- axis_neuron
Number of the axis neuron \(M_2\) (number of columns of the sub-matrix of the embedding matrix)
- resnet_dt
Time-step dt in the resnet construction: y = x + dt * phi (Wx + b)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- type_one_side
Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- exclude_types
List[List[int]] 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.
- set_davg_zero
Set the shift of embedding net input to zero.
- activation_function
The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”.
- 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
- attn
The length of hidden vector during scale-dot attention computation.
- attn_layer
The number of layers in attention mechanism.
- attn_dotr
Whether to dot the relative coordinates on the attention weights as a gated scheme.
- attn_mask
Whether to mask the diagonal in the attention weights.
- multi_task
If the model has multi fitting nets to train.
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
get_dim_out()Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
get_nlist()- Returns
get_ntypes()Returns the number of atom types
get_rcut()Returns the cut-off radius
get_rot_mat()Get rotational matrix
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict, mixed_type: bool = False, real_natoms_vec: Optional[list] = None) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. If mixed_type is True, this para is blank. See real_natoms_vec.
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional 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.
- real_natoms_vec
If mixed_type is True, it takes in the real natoms_vec for each frame.
deepmd.descriptor.se_r module
- class deepmd.descriptor.se_r.DescrptSeR(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se.DescrptSeDeepPot-SE constructed from radial information of atomic configurations.
The embedding takes the distance between atoms as input.
- Parameters
- rcut
The cut-off radius
- rcut_smth
From where the environment matrix should be smoothed
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] 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)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- type_one_side
Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets
- exclude_types
List[List[int]] 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 “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”.
- 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
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
- Returns
Returns the number of atom types
get_rcut()Returns the cut-off radius
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord, data_box, data_atype, natoms_vec, mesh, input_dict)[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- enable_compression(min_nbor_dist: float, graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, table_extrapolate: float = 5, table_stride_1: float = 0.01, table_stride_2: float = 0.1, check_frequency: int = - 1, suffix: str = '') None[source]
Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
- Parameters
- min_nbor_dist
The nearest distance between atoms
- grapf
tf.Graph The graph of the model
- graph_def
tf.GraphDef The graph_def of the model
- table_extrapolate
The scale of model extrapolation
- table_stride_1
The uniform stride of the first table
- table_stride_2
The uniform stride of the second table
- check_frequency
The overflow check frequency
- suffix
str,optional The suffix of the scope
- get_nlist()[source]
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- merge_input_stats(stat_dict)[source]
Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
- Parameters
- stat_dict
The dict of statisitcs computed from compute_input_stats, including:
- sumr
The sum of radial statisitcs.
- sumn
The sum of neighbor numbers.
- sumr2
The sum of square of radial statisitcs.
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
deepmd.descriptor.se_t module
- class deepmd.descriptor.se_t.DescrptSeT(*args, **kwargs)[source]
Bases:
deepmd.descriptor.se.DescrptSeDeepPot-SE constructed from all information (both angular and radial) of atomic configurations.
The embedding takes angles between two neighboring atoms as input.
- Parameters
- rcut
The cut-off radius
- rcut_smth
From where the environment matrix should be smoothed
- sel
list[str] sel[i] specifies the maxmum number of type i atoms in the cut-off radius
- neuron
list[int] 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)
- trainable
If the weights of embedding net are trainable.
- seed
Random seed for initializing the network parameters.
- set_davg_zero
Set the shift of embedding net input to zero.
- activation_function
The activation function in the embedding net. Supported options are “relu”, “relu6”, “softplus”, “sigmoid”, “tanh”, “gelu”, “gelu_tf”.
- 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
- Attributes
precisionPrecision of filter network.
Methods
build(coord_, atype_, natoms, box_, mesh, ...)Build the computational graph for the descriptor
build_type_exclude_mask(exclude_types, ...)Build the type exclude mask for the descriptor.
compute_input_stats(data_coord, data_box, ...)Compute the statisitcs (avg and std) of the training data.
enable_compression(min_nbor_dist, graph, ...)Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
enable_mixed_precision([mixed_prec])Reveive the mixed precision setting.
Returns the output dimension of this descriptor
get_dim_rot_mat_1()Returns the first dimension of the rotation matrix.
get_feed_dict(coord_, atype_, natoms, box, mesh)Generate the feed_dict for current descriptor
- Returns
Returns the number of atom types
get_rcut()Returns the cut-off radius
get_tensor_names([suffix])Get names of tensors.
init_variables(graph, graph_def[, suffix])Init the embedding net variables with the given dict
merge_input_stats(stat_dict)Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
pass_tensors_from_frz_model(descrpt_reshape, ...)Pass the descrpt_reshape tensor as well as descrpt_deriv tensor from the frz graph_def
prod_force_virial(atom_ener, natoms)Compute force and virial
register(key)Regiester a descriptor plugin.
- build(coord_: tensorflow.python.framework.ops.Tensor, atype_: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, box_: tensorflow.python.framework.ops.Tensor, mesh: tensorflow.python.framework.ops.Tensor, input_dict: dict, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the descriptor
- Parameters
- coord_
The coordinate of atoms
- atype_
The type of atoms
- 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
- mesh
For historical reasons, only the length of the Tensor matters. if size of mesh == 6, pbc is assumed. if size of mesh == 0, no-pbc is assumed.
- input_dict
Dictionary for additional inputs
- reuse
The weights in the networks should be reused when get the variable.
- suffix
Name suffix to identify this descriptor
- Returns
descriptorThe output descriptor
- compute_input_stats(data_coord: list, data_box: list, data_atype: list, natoms_vec: list, mesh: list, input_dict: dict) None[source]
Compute the statisitcs (avg and std) of the training data. The input will be normalized by the statistics.
- Parameters
- data_coord
The coordinates. Can be generated by deepmd.model.make_stat_input
- data_box
The box. Can be generated by deepmd.model.make_stat_input
- data_atype
The atom types. Can be generated by deepmd.model.make_stat_input
- natoms_vec
The vector for the number of atoms of the system and different types of atoms. Can be generated by deepmd.model.make_stat_input
- mesh
The mesh for neighbor searching. Can be generated by deepmd.model.make_stat_input
- input_dict
Dictionary for additional input
- enable_compression(min_nbor_dist: float, graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, table_extrapolate: float = 5, table_stride_1: float = 0.01, table_stride_2: float = 0.1, check_frequency: int = - 1, suffix: str = '') None[source]
Reveive the statisitcs (distance, max_nbor_size and env_mat_range) of the training data.
- Parameters
- min_nbor_dist
The nearest distance between atoms
- grapf
tf.Graph The graph of the model
- graph_def
tf.GraphDef The graph_def of the model
- table_extrapolate
The scale of model extrapolation
- table_stride_1
The uniform stride of the first table
- table_stride_2
The uniform stride of the second table
- check_frequency
The overflow check frequency
- suffix
str,optional The suffix of the scope
- get_nlist() Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, List[int], List[int]][source]
- Returns
nlistNeighbor list
rijThe relative distance between the neighbor and the center atom.
sel_aThe number of neighbors with full information
sel_rThe number of neighbors with only radial information
- merge_input_stats(stat_dict)[source]
Merge the statisitcs computed from compute_input_stats to obtain the self.davg and self.dstd.
- Parameters
- stat_dict
The dict of statisitcs computed from compute_input_stats, including:
- sumr
The sum of radial statisitcs.
- suma
The sum of relative coord statisitcs.
- sumn
The sum of neighbor numbers.
- sumr2
The sum of square of radial statisitcs.
- suma2
The sum of square of relative coord statisitcs.
- prod_force_virial(atom_ener: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor) Tuple[tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor, tensorflow.python.framework.ops.Tensor][source]
Compute force and virial
- Parameters
- atom_ener
The atomic energy
- 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
- Returns
forceThe force on atoms
virialThe total virial
atom_virialThe atomic virial
deepmd.entrypoints package
Submodule that contains all the DeePMD-Kit entry point scripts.
- deepmd.entrypoints.compress(*, input: str, output: str, extrapolate: int, step: float, frequency: str, checkpoint_folder: str, training_script: str, mpi_log: str, log_path: Optional[str], 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
- input
str frozen model file to compress
- output
str compressed model filename
- extrapolate
int scale of model extrapolation
- step
float uniform step size of the tabulation’s first table
- frequency
str frequency of tabulation overflow check
- checkpoint_folder
str trining checkpoint folder for freezing
- training_script
str training script of the input frozen model
- mpi_log
str mpi logging mode for training
- log_path
Optional[str] if speccified log will be written to this file
- log_level
int logging level
- input
- deepmd.entrypoints.config(*, output: str, **kwargs)[source]
Auto config file generator.
- Parameters
- output: str
file to write config file
- Raises
RuntimeErrorif user does not input any systems
ValueErrorif output file is of wrong type
- deepmd.entrypoints.doc_train_input(*, out_type: str = 'rst', **kwargs)[source]
Print out trining input arguments to console.
- deepmd.entrypoints.freeze(*, checkpoint_folder: str, output: str, node_names: Optional[str] = None, nvnmd_weight: Optional[str] = None, **kwargs)[source]
Freeze the graph in supplied folder.
- deepmd.entrypoints.make_model_devi(*, models: list, system: str, set_prefix: str, output: str, frequency: int, **kwargs)[source]
Make model deviation calculation
- Parameters
- models: list
A list of paths of models to use for making model deviation
- system: str
The path of system to make model deviation calculation
- set_prefix: str
The set prefix of the system
- output: str
The output file for model deviation results
- frequency: int
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.
- deepmd.entrypoints.neighbor_stat(*, system: str, rcut: float, type_map: List[str], one_type: bool = False, **kwargs)[source]
Calculate neighbor statistics.
- Parameters
Examples
>>> neighbor_stat(system='.', rcut=6., 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.entrypoints.test(*, model: str, system: str, set_prefix: str, numb_test: int, rand_seed: Optional[int], shuffle_test: bool, detail_file: str, atomic: bool, **kwargs)[source]
Test model predictions.
- Parameters
- model
str path where model is stored
- system
str system directory
- set_prefix
str string prefix of set
- numb_test
int munber of tests to do
- rand_seed
Optional[int] seed for random generator
- shuffle_testbool
whether to shuffle tests
- detail_file
Optional[str] file where test details will be output
- atomicbool
whether per atom quantities should be computed
- model
- Raises
RuntimeErrorif no valid system was found
- deepmd.entrypoints.train_dp(*, INPUT: str, init_model: Optional[str], restart: Optional[str], output: str, init_frz_model: str, mpi_log: str, log_level: int, log_path: Optional[str], is_compress: bool = False, skip_neighbor_stat: bool = False, finetune: Optional[str] = None, **kwargs)
Run DeePMD model training.
- Parameters
- INPUT
str json/yaml control file
- init_model
Optional[str] path to checkpoint folder or None
- restart
Optional[str] path to checkpoint folder or None
- output
str path for dump file with arguments
- init_frz_model
str path to frozen model or None
- mpi_log
str mpi logging mode
- log_level
int logging level defined by int 0-3
- log_path
Optional[str] logging file path or None if logs are to be output only to stdout
- is_compress: bool
indicates whether in the model compress mode
- skip_neighbor_statbool, default=False
skip checking neighbor statistics
- finetune
Optional[str] path to pretrained model or None
- INPUT
- Raises
RuntimeErrorif distributed training job nem is wrong
- deepmd.entrypoints.transfer(*, old_model: str, raw_model: str, output: str, **kwargs)[source]
Transfer operation from old fron graph to new prepared raw graph.
Submodules
deepmd.entrypoints.compress module
Compress a model, which including tabulating the embedding-net.
- deepmd.entrypoints.compress.compress(*, input: str, output: str, extrapolate: int, step: float, frequency: str, checkpoint_folder: str, training_script: str, mpi_log: str, log_path: Optional[str], 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
- input
str frozen model file to compress
- output
str compressed model filename
- extrapolate
int scale of model extrapolation
- step
float uniform step size of the tabulation’s first table
- frequency
str frequency of tabulation overflow check
- checkpoint_folder
str trining checkpoint folder for freezing
- training_script
str training script of the input frozen model
- mpi_log
str mpi logging mode for training
- log_path
Optional[str] if speccified log will be written to this file
- log_level
int logging level
- input
deepmd.entrypoints.config module
Quickly create a configuration file for smooth model.
- deepmd.entrypoints.config.config(*, output: str, **kwargs)[source]
Auto config file generator.
- Parameters
- output: str
file to write config file
- Raises
RuntimeErrorif user does not input any systems
ValueErrorif output file is of wrong type
deepmd.entrypoints.convert module
deepmd.entrypoints.doc module
Module that prints train input arguments docstrings.
deepmd.entrypoints.freeze module
Script for freezing TF trained graph so it can be used with LAMMPS and i-PI.
deepmd.entrypoints.main module
DeePMD-Kit entry point module.
- deepmd.entrypoints.main.main(args: Optional[List[str]] = None)[source]
DeePMD-Kit entry point.
- Parameters
- args: List[str], optional
list of command line arguments, used to avoid calling from the subprocess, as it is quite slow to import tensorflow
- Raises
RuntimeErrorif no command was input
- deepmd.entrypoints.main.main_parser() argparse.ArgumentParser[source]
DeePMD-Kit commandline options argument parser.
- Returns
argparse.ArgumentParsermain parser of DeePMD-kit
- deepmd.entrypoints.main.parse_args(args: Optional[List[str]] = None) argparse.Namespace[source]
Parse arguments and convert argument strings to objects.
- Parameters
- args: List[str]
list of command line arguments, main purpose is testing default option None takes arguments from sys.argv
- Returns
argparse.Namespacethe populated namespace
deepmd.entrypoints.neighbor_stat module
- deepmd.entrypoints.neighbor_stat.neighbor_stat(*, system: str, rcut: float, type_map: List[str], one_type: bool = False, **kwargs)[source]
Calculate neighbor statistics.
- Parameters
Examples
>>> neighbor_stat(system='.', rcut=6., 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.entrypoints.test module
Test trained DeePMD model.
- deepmd.entrypoints.test.test(*, model: str, system: str, set_prefix: str, numb_test: int, rand_seed: Optional[int], shuffle_test: bool, detail_file: str, atomic: bool, **kwargs)[source]
Test model predictions.
- Parameters
- model
str path where model is stored
- system
str system directory
- set_prefix
str string prefix of set
- numb_test
int munber of tests to do
- rand_seed
Optional[int] seed for random generator
- shuffle_testbool
whether to shuffle tests
- detail_file
Optional[str] file where test details will be output
- atomicbool
whether per atom quantities should be computed
- model
- Raises
RuntimeErrorif no valid system was found
deepmd.entrypoints.train module
DeePMD training entrypoint script.
Can handle local or distributed training.
- deepmd.entrypoints.train.train(*, INPUT: str, init_model: Optional[str], restart: Optional[str], output: str, init_frz_model: str, mpi_log: str, log_level: int, log_path: Optional[str], is_compress: bool = False, skip_neighbor_stat: bool = False, finetune: Optional[str] = None, **kwargs)[source]
Run DeePMD model training.
- Parameters
- INPUT
str json/yaml control file
- init_model
Optional[str] path to checkpoint folder or None
- restart
Optional[str] path to checkpoint folder or None
- output
str path for dump file with arguments
- init_frz_model
str path to frozen model or None
- mpi_log
str mpi logging mode
- log_level
int logging level defined by int 0-3
- log_path
Optional[str] logging file path or None if logs are to be output only to stdout
- is_compress: bool
indicates whether in the model compress mode
- skip_neighbor_statbool, default=False
skip checking neighbor statistics
- finetune
Optional[str] path to pretrained model or None
- INPUT
- Raises
RuntimeErrorif distributed training job nem is wrong
deepmd.entrypoints.transfer module
Module used for transfering parameters between models.
deepmd.fit package
Submodules
deepmd.fit.dipole module
- class deepmd.fit.dipole.DipoleFittingSeA(descrpt: tensorflow.python.framework.ops.Tensor, neuron: List[int] = [120, 120, 120], resnet_dt: bool = True, sel_type: Optional[List[int]] = None, seed: Optional[int] = None, activation_function: str = 'tanh', precision: str = 'default', uniform_seed: bool = False)[source]
Bases:
deepmd.fit.fitting.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”.
- 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 the output size.
Get selected type
init_variables(graph, graph_def[, suffix])Init the fitting net variables with the given dict
- build(input_d: tensorflow.python.framework.ops.Tensor, rot_mat: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, input_dict: Optional[dict] = None, reuse: bool = None, suffix: str = '') tensorflow.python.framework.ops.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.ener module
- class deepmd.fit.ener.EnerFitting(descrpt: tensorflow.python.framework.ops.Tensor, neuron: List[int] = [120, 120, 120], resnet_dt: bool = True, numb_fparam: int = 0, numb_aparam: int = 0, rcond: float = 0.001, tot_ener_zero: bool = False, trainable: Optional[List[bool]] = None, seed: Optional[int] = None, atom_ener: List[float] = [], activation_function: str = 'tanh', precision: str = 'default', uniform_seed: bool = False)[source]
Bases:
deepmd.fit.fitting.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”.
- 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
- 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 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
- build(inputs: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, input_dict: Optional[dict] = None, reuse: Optional[bool] = None, suffix: str = '') tensorflow.python.framework.ops.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[source]
Bases:
object- Attributes
precisionPrecision of fitting network.
Methods
init_variables(graph, graph_def[, suffix])Init the fitting net variables with the given dict
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.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: tensorflow.python.framework.dtypes.DType
Precision of fitting network.
deepmd.fit.polar module
- class deepmd.fit.polar.GlobalPolarFittingSeA(descrpt: tensorflow.python.framework.ops.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”.
- 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 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='') tensorflow.python.framework.ops.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(descrpt: tensorflow.python.framework.ops.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, shift_diag: bool = True, seed: Optional[int] = None, activation_function: str = 'tanh', precision: str = 'default', uniform_seed: bool = False)[source]
Bases:
deepmd.fit.fitting.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”.
- 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 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: tensorflow.python.framework.ops.Tensor, rot_mat: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, input_dict: Optional[dict] = None, reuse: 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
- 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.infer package
Submodule containing all the implemented potentials.
- class deepmd.infer.DeepDipole(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- class deepmd.infer.DeepEval(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False, auto_batch_size: Union[bool, int, deepmd.utils.batch_size.AutoBatchSize] = False)[source]
Bases:
objectCommon methods for DeepPot, DeepWFC, DeepPolar, …
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- auto_batch_sizebool or
intorAutomaticBatchSize, default:False If True, automatic batch size will be used. If int, it will be used as the initial batch size.
- model_file
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- make_natoms_vec(atom_types: numpy.ndarray, mixed_type: bool = False) numpy.ndarray[source]
Make the natom vector used by deepmd-kit.
- Parameters
- atom_types
The type of atoms
- 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.
- Returns
natomsThe 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
- static reverse_map(vec: numpy.ndarray, imap: List[int]) numpy.ndarray[source]
Reverse mapping of a vector according to the index map
- Parameters
- vec
Input vector. Be of shape [nframes, natoms, -1]
- imap
Index map. Be of shape [natoms]
- Returns
vec_outReverse mapped vector.
- property sess: tensorflow.python.client.session.Session
Get TF session.
- static sort_input(coord: numpy.ndarray, atom_type: numpy.ndarray, sel_atoms: Optional[List[int]] = None, mixed_type: bool = False)[source]
Sort atoms in the system according their types.
- Parameters
- coord
The coordinates of atoms. Should be of shape [nframes, natoms, 3]
- atom_type
The type of atoms Should be of shape [natoms]
- sel_atoms
The selected atoms by type
- 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.
- Returns
coord_outThe coordinates after sorting
atom_type_outThe atom types after sorting
idx_mapThe index mapping from the input to the output. For example coord_out = coord[:,idx_map,:]
sel_atom_typeOnly output if sel_atoms is not None The sorted selected atom types
sel_idx_mapOnly output if sel_atoms is not None The index mapping from the selected atoms to sorted selected atoms.
- class deepmd.infer.DeepGlobalPolar(model_file: str, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- eval(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = False, fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None) numpy.ndarray[source]
Evaluate the model.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
Not used in this model
- fparam
Not used in this model
- aparam
Not used in this model
- efield
Not used in this model
- Returns
tensorThe returned tensor If atomic == False then of size nframes x variable_dof else of size nframes x natoms x variable_dof
- class deepmd.infer.DeepPolar(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- class deepmd.infer.DeepPot(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False, auto_batch_size: Union[bool, int, deepmd.utils.batch_size.AutoBatchSize] = True)[source]
Bases:
deepmd.infer.deep_eval.DeepEvalConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- auto_batch_sizebool or
intorAutomaticBatchSize, default:True If True, automatic batch size will be used. If int, it will be used as the initial batch size.
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
Examples
>>> from deepmd.infer import DeepPot >>> import numpy as np >>> dp = DeepPot('graph.pb') >>> coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1]) >>> cell = np.diag(10 * np.ones(3)).reshape([1, -1]) >>> atype = [1,0,1] >>> e, f, v = dp.eval(coord, cell, atype)
where e, f and v are predicted energy, force and virial of the system, respectively.
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the energy, force and virial by using this DP.
eval_descriptor(coords, cells, atom_types[, ...])Evaluate descriptors by using this DP.
Get the number (dimension) of atomic parameters of this DP.
Get the number (dimension) of frame parameters of this DP.
Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
Unsupported in this model.
Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- eval(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = False, fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None, mixed_type: bool = False) Tuple[numpy.ndarray, ...][source]
Evaluate the energy, force and virial by using this DP.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
Calculate the atomic energy and virial
- fparam
The frame parameter. The array can be of size : - nframes x dim_fparam. - dim_fparam. Then all frames are assumed to be provided with the same fparam.
- aparam
The atomic parameter The array can be of size : - nframes x natoms x dim_aparam. - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. - dim_aparam. Then all frames and atoms are provided with the same aparam.
- efield
The external field on atoms. The array should be of size nframes x natoms x 3
- 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.
- Returns
- ——-
- energy
The system energy.
- force
The force on each atom
- virial
The virial
- atom_energy
The atomic energy. Only returned when atomic == True
- atom_virial
The atomic virial. Only returned when atomic == True
- eval_descriptor(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None, mixed_type: bool = False) numpy.array[source]
Evaluate descriptors by using this DP.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- fparam
The frame parameter. The array can be of size : - nframes x dim_fparam. - dim_fparam. Then all frames are assumed to be provided with the same fparam.
- aparam
The atomic parameter The array can be of size : - nframes x natoms x dim_aparam. - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. - dim_aparam. Then all frames and atoms are provided with the same aparam.
- efield
The external field on atoms. The array should be of size nframes x natoms x 3
- 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.
- Returns
descriptorDescriptors.
- deepmd.infer.DeepPotential(model_file: Union[str, pathlib.Path], load_prefix: str = 'load', default_tf_graph: bool = False) Union[deepmd.infer.deep_dipole.DeepDipole, deepmd.infer.deep_polar.DeepGlobalPolar, deepmd.infer.deep_polar.DeepPolar, deepmd.infer.deep_pot.DeepPot, deepmd.infer.deep_wfc.DeepWFC][source]
Factory function that will inialize appropriate potential read from model_file.
- Parameters
- model_file: str
The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- Returns
Union[DeepDipole,DeepGlobalPolar,DeepPolar,DeepPot,DeepWFC]one of the available potentials
- Raises
RuntimeErrorif model file does not correspond to any implementd potential
- class deepmd.infer.DeepWFC(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- class deepmd.infer.DipoleChargeModifier(model_name: str, model_charge_map: List[float], sys_charge_map: List[float], ewald_h: float = 1, ewald_beta: float = 1)[source]
Bases:
deepmd.infer.deep_dipole.DeepDipole- Parameters
- model_name
The model file for the DeepDipole model
- model_charge_map
Gives the amount of charge for the wfcc
- sys_charge_map
Gives the amount of charge for the real atoms
- ewald_h
Grid spacing of the reciprocal part of Ewald sum. Unit: A
- ewald_beta
Splitting parameter of the Ewald sum. Unit: A^{-1}
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
Build the computational graph for the force and virial inference.
eval(coord, box, atype[, eval_fv])Evaluate the modification
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
get_dim_aparam()Unsupported in this model.
get_dim_fparam()Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
modify_data(data)Modify data.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- build_fv_graph() tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the force and virial inference.
- eval(coord: numpy.ndarray, box: numpy.ndarray, atype: numpy.ndarray, eval_fv: bool = True) Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray][source]
Evaluate the modification
- Parameters
- coord
The coordinates of atoms
- box
The simulation region. PBC is assumed
- atype
The atom types
- eval_fv
Evaluate force and virial
- Returns
tot_eThe energy modification
tot_fThe force modification
tot_vThe virial modification
- modify_data(data: dict) None[source]
Modify data.
- Parameters
- data
Internal data of DeepmdData. Be a dict, has the following keys - coord coordinates - box simulation box - type atom types - find_energy tells if data has energy - find_force tells if data has force - find_virial tells if data has virial - energy energy - force force - virial virial
- class deepmd.infer.EwaldRecp(hh, beta)[source]
Bases:
objectEvaluate the reciprocal part of the Ewald sum
Methods
eval(coord, charge, box)Evaluate
- eval(coord: numpy.ndarray, charge: numpy.ndarray, box: numpy.ndarray) Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray][source]
Evaluate
- Parameters
- coord
The coordinates of atoms
- charge
The atomic charge
- box
The simulation region. PBC is assumed
- Returns
eThe energy
fThe force
vThe virial
- deepmd.infer.calc_model_devi(coord, box, atype, models, fname=None, frequency=1)[source]
Python interface to calculate model deviation
- Parameters
- coord
numpy.ndarray, n_frames x n_atoms x 3 Coordinates of system to calculate
- box
numpy.ndarrayorNone, n_frames x 3 x 3 Box to specify periodic boundary condition. If None, no pbc will be used
- atype
numpy.ndarray, n_atoms x 1 Atom types
- models
listofDeepPotmodels Models used to evaluate deviation
- fname
strorNone File to dump results, default None
- frequency
int Steps between frames (if the system is given by molecular dynamics engine), default 1
- coord
- Returns
- model_devi
numpy.ndarray, n_frames x 7 Model deviation results. The first column is index of steps, the other 6 columns are max_devi_v, min_devi_v, avg_devi_v, max_devi_f, min_devi_f, avg_devi_f.
- model_devi
Examples
>>> from deepmd.infer import calc_model_devi >>> from deepmd.infer import DeepPot as DP >>> import numpy as np >>> coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1]) >>> cell = np.diag(10 * np.ones(3)).reshape([1, -1]) >>> atype = [1,0,1] >>> graphs = [DP("graph.000.pb"), DP("graph.001.pb")] >>> model_devi = calc_model_devi(coord, cell, atype, graphs)
Submodules
deepmd.infer.data_modifier module
- class deepmd.infer.data_modifier.DipoleChargeModifier(model_name: str, model_charge_map: List[float], sys_charge_map: List[float], ewald_h: float = 1, ewald_beta: float = 1)[source]
Bases:
deepmd.infer.deep_dipole.DeepDipole- Parameters
- model_name
The model file for the DeepDipole model
- model_charge_map
Gives the amount of charge for the wfcc
- sys_charge_map
Gives the amount of charge for the real atoms
- ewald_h
Grid spacing of the reciprocal part of Ewald sum. Unit: A
- ewald_beta
Splitting parameter of the Ewald sum. Unit: A^{-1}
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
Build the computational graph for the force and virial inference.
eval(coord, box, atype[, eval_fv])Evaluate the modification
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
get_dim_aparam()Unsupported in this model.
get_dim_fparam()Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
modify_data(data)Modify data.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- build_fv_graph() tensorflow.python.framework.ops.Tensor[source]
Build the computational graph for the force and virial inference.
- eval(coord: numpy.ndarray, box: numpy.ndarray, atype: numpy.ndarray, eval_fv: bool = True) Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray][source]
Evaluate the modification
- Parameters
- coord
The coordinates of atoms
- box
The simulation region. PBC is assumed
- atype
The atom types
- eval_fv
Evaluate force and virial
- Returns
tot_eThe energy modification
tot_fThe force modification
tot_vThe virial modification
- modify_data(data: dict) None[source]
Modify data.
- Parameters
- data
Internal data of DeepmdData. Be a dict, has the following keys - coord coordinates - box simulation box - type atom types - find_energy tells if data has energy - find_force tells if data has force - find_virial tells if data has virial - energy energy - force force - virial virial
deepmd.infer.deep_dipole module
- class deepmd.infer.deep_dipole.DeepDipole(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
deepmd.infer.deep_eval module
- class deepmd.infer.deep_eval.DeepEval(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False, auto_batch_size: Union[bool, int, deepmd.utils.batch_size.AutoBatchSize] = False)[source]
Bases:
objectCommon methods for DeepPot, DeepWFC, DeepPolar, …
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- auto_batch_sizebool or
intorAutomaticBatchSize, default:False If True, automatic batch size will be used. If int, it will be used as the initial batch size.
- model_file
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- make_natoms_vec(atom_types: numpy.ndarray, mixed_type: bool = False) numpy.ndarray[source]
Make the natom vector used by deepmd-kit.
- Parameters
- atom_types
The type of atoms
- 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.
- Returns
natomsThe 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
- static reverse_map(vec: numpy.ndarray, imap: List[int]) numpy.ndarray[source]
Reverse mapping of a vector according to the index map
- Parameters
- vec
Input vector. Be of shape [nframes, natoms, -1]
- imap
Index map. Be of shape [natoms]
- Returns
vec_outReverse mapped vector.
- property sess: tensorflow.python.client.session.Session
Get TF session.
- static sort_input(coord: numpy.ndarray, atom_type: numpy.ndarray, sel_atoms: Optional[List[int]] = None, mixed_type: bool = False)[source]
Sort atoms in the system according their types.
- Parameters
- coord
The coordinates of atoms. Should be of shape [nframes, natoms, 3]
- atom_type
The type of atoms Should be of shape [natoms]
- sel_atoms
The selected atoms by type
- 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.
- Returns
coord_outThe coordinates after sorting
atom_type_outThe atom types after sorting
idx_mapThe index mapping from the input to the output. For example coord_out = coord[:,idx_map,:]
sel_atom_typeOnly output if sel_atoms is not None The sorted selected atom types
sel_idx_mapOnly output if sel_atoms is not None The index mapping from the selected atoms to sorted selected atoms.
deepmd.infer.deep_polar module
- class deepmd.infer.deep_polar.DeepGlobalPolar(model_file: str, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- eval(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = False, fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None) numpy.ndarray[source]
Evaluate the model.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
Not used in this model
- fparam
Not used in this model
- aparam
Not used in this model
- efield
Not used in this model
- Returns
tensorThe returned tensor If atomic == False then of size nframes x variable_dof else of size nframes x natoms x variable_dof
- class deepmd.infer.deep_polar.DeepPolar(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
deepmd.infer.deep_pot module
- class deepmd.infer.deep_pot.DeepPot(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False, auto_batch_size: Union[bool, int, deepmd.utils.batch_size.AutoBatchSize] = True)[source]
Bases:
deepmd.infer.deep_eval.DeepEvalConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- auto_batch_sizebool or
intorAutomaticBatchSize, default:True If True, automatic batch size will be used. If int, it will be used as the initial batch size.
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
Examples
>>> from deepmd.infer import DeepPot >>> import numpy as np >>> dp = DeepPot('graph.pb') >>> coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1]) >>> cell = np.diag(10 * np.ones(3)).reshape([1, -1]) >>> atype = [1,0,1] >>> e, f, v = dp.eval(coord, cell, atype)
where e, f and v are predicted energy, force and virial of the system, respectively.
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the energy, force and virial by using this DP.
eval_descriptor(coords, cells, atom_types[, ...])Evaluate descriptors by using this DP.
Get the number (dimension) of atomic parameters of this DP.
Get the number (dimension) of frame parameters of this DP.
Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
Unsupported in this model.
Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- eval(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = False, fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None, mixed_type: bool = False) Tuple[numpy.ndarray, ...][source]
Evaluate the energy, force and virial by using this DP.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
Calculate the atomic energy and virial
- fparam
The frame parameter. The array can be of size : - nframes x dim_fparam. - dim_fparam. Then all frames are assumed to be provided with the same fparam.
- aparam
The atomic parameter The array can be of size : - nframes x natoms x dim_aparam. - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. - dim_aparam. Then all frames and atoms are provided with the same aparam.
- efield
The external field on atoms. The array should be of size nframes x natoms x 3
- 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.
- Returns
- ——-
- energy
The system energy.
- force
The force on each atom
- virial
The virial
- atom_energy
The atomic energy. Only returned when atomic == True
- atom_virial
The atomic virial. Only returned when atomic == True
- eval_descriptor(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None, mixed_type: bool = False) numpy.array[source]
Evaluate descriptors by using this DP.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- fparam
The frame parameter. The array can be of size : - nframes x dim_fparam. - dim_fparam. Then all frames are assumed to be provided with the same fparam.
- aparam
The atomic parameter The array can be of size : - nframes x natoms x dim_aparam. - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. - dim_aparam. Then all frames and atoms are provided with the same aparam.
- efield
The external field on atoms. The array should be of size nframes x natoms x 3
- 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.
- Returns
descriptorDescriptors.
deepmd.infer.deep_tensor module
- class deepmd.infer.deep_tensor.DeepTensor(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_eval.DeepEvalEvaluates a tensor model.
- Parameters
- model_file: str
The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Get the number (dimension) of atomic parameters of this DP.
Get the number (dimension) of frame parameters of this DP.
Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
Get the selected atom types of this model.
Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
- eval(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = True, fparam: Optional[numpy.ndarray] = None, aparam: Optional[numpy.ndarray] = None, efield: Optional[numpy.ndarray] = None, mixed_type: bool = False) numpy.ndarray[source]
Evaluate the model.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
If True (default), return the atomic tensor Otherwise return the global tensor
- fparam
Not used in this model
- aparam
Not used in this model
- efield
Not used in this model
- 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.
- Returns
tensorThe returned tensor If atomic == False then of size nframes x output_dim else of size nframes x natoms x output_dim
- eval_full(coords: numpy.ndarray, cells: numpy.ndarray, atom_types: List[int], atomic: bool = False, fparam: Optional[numpy.array] = None, aparam: Optional[numpy.array] = None, efield: Optional[numpy.array] = None, mixed_type: bool = False) Tuple[numpy.ndarray, ...][source]
Evaluate the model with interface similar to the energy model. Will return global tensor, component-wise force and virial and optionally atomic tensor and atomic virial.
- Parameters
- coords
The coordinates of atoms. The array should be of size nframes x natoms x 3
- cells
The cell of the region. If None then non-PBC is assumed, otherwise using PBC. The array should be of size nframes x 9
- atom_types
The atom types The list should contain natoms ints
- atomic
Whether to calculate atomic tensor and virial
- fparam
Not used in this model
- aparam
Not used in this model
- efield
Not used in this model
- 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.
- Returns
tensorThe global tensor. shape: [nframes x nout]
forceThe component-wise force (negative derivative) on each atom. shape: [nframes x nout x natoms x 3]
virialThe component-wise virial of the tensor. shape: [nframes x nout x 9]
atom_tensorThe atomic tensor. Only returned when atomic == True shape: [nframes x natoms x nout]
atom_virialThe atomic virial. Only returned when atomic == True shape: [nframes x nout x natoms x 9]
- tensors = {'t_box': 't_box:0', 't_coord': 't_coord:0', 't_mesh': 't_mesh:0', 't_natoms': 't_natoms:0', 't_ntypes': 'descrpt_attr/ntypes:0', 't_ouput_dim': 'model_attr/output_dim:0', 't_rcut': 'descrpt_attr/rcut:0', 't_sel_type': 'model_attr/sel_type:0', 't_tmap': 'model_attr/tmap:0', 't_type': 't_type:0'}
deepmd.infer.deep_wfc module
- class deepmd.infer.deep_wfc.DeepWFC(model_file: Path, load_prefix: str = 'load', default_tf_graph: bool = False)[source]
Bases:
deepmd.infer.deep_tensor.DeepTensorConstructor.
- Parameters
- model_file
Path The name of the frozen model file.
- load_prefix: str
The prefix in the load computational graph
- default_tf_graphbool
If uses the default tf graph, otherwise build a new tf graph for evaluation
- model_file
Warning
For developers: DeepTensor initializer must be called at the end after self.tensors are modified because it uses the data in self.tensors dict. Do not chanage the order!
- Attributes
model_typeGet type of model.
model_versionGet version of model.
sessGet TF session.
Methods
eval(coords, cells, atom_types[, atomic, ...])Evaluate the model.
eval_full(coords, cells, atom_types[, ...])Evaluate the model with interface similar to the energy model.
Unsupported in this model.
Unsupported in this model.
get_ntypes()Get the number of atom types of this model.
get_rcut()Get the cut-off radius of this model.
get_sel_type()Get the selected atom types of this model.
get_type_map()Get the type map (element name of the atom types) of this model.
make_natoms_vec(atom_types[, mixed_type])Make the natom vector used by deepmd-kit.
reverse_map(vec, imap)Reverse mapping of a vector according to the index map
sort_input(coord, atom_type[, sel_atoms, ...])Sort atoms in the system according their types.
deepmd.infer.ewald_recp module
- class deepmd.infer.ewald_recp.EwaldRecp(hh, beta)[source]
Bases:
objectEvaluate the reciprocal part of the Ewald sum
Methods
eval(coord, charge, box)Evaluate
- eval(coord: numpy.ndarray, charge: numpy.ndarray, box: numpy.ndarray) Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray][source]
Evaluate
- Parameters
- coord
The coordinates of atoms
- charge
The atomic charge
- box
The simulation region. PBC is assumed
- Returns
eThe energy
fThe force
vThe virial
deepmd.infer.model_devi module
- deepmd.infer.model_devi.calc_model_devi(coord, box, atype, models, fname=None, frequency=1)[source]
Python interface to calculate model deviation
- Parameters
- coord
numpy.ndarray, n_frames x n_atoms x 3 Coordinates of system to calculate
- box
numpy.ndarrayorNone, n_frames x 3 x 3 Box to specify periodic boundary condition. If None, no pbc will be used
- atype
numpy.ndarray, n_atoms x 1 Atom types
- models
listofDeepPotmodels Models used to evaluate deviation
- fname
strorNone File to dump results, default None
- frequency
int Steps between frames (if the system is given by molecular dynamics engine), default 1
- coord
- Returns
- model_devi
numpy.ndarray, n_frames x 7 Model deviation results. The first column is index of steps, the other 6 columns are max_devi_v, min_devi_v, avg_devi_v, max_devi_f, min_devi_f, avg_devi_f.
- model_devi
Examples
>>> from deepmd.infer import calc_model_devi >>> from deepmd.infer import DeepPot as DP >>> import numpy as np >>> coord = np.array([[1,0,0], [0,0,1.5], [1,0,3]]).reshape([1, -1]) >>> cell = np.diag(10 * np.ones(3)).reshape([1, -1]) >>> atype = [1,0,1] >>> graphs = [DP("graph.000.pb"), DP("graph.001.pb")] >>> model_devi = calc_model_devi(coord, cell, atype, graphs)
- deepmd.infer.model_devi.calc_model_devi_e(es: numpy.ndarray)[source]
- Parameters
- es
numpy.ndarray size of `n_models x n_frames x n_atoms
- es
- deepmd.infer.model_devi.calc_model_devi_f(fs: numpy.ndarray)[source]
- Parameters
- fs
numpy.ndarray size of n_models x n_frames x n_atoms x 3
- fs
- deepmd.infer.model_devi.calc_model_devi_v(vs: numpy.ndarray)[source]
- Parameters
- vs
numpy.ndarray size of n_models x n_frames x 9
- vs
- deepmd.infer.model_devi.make_model_devi(*, models: list, system: str, set_prefix: str, output: str, frequency: int, **kwargs)[source]
Make model deviation calculation
- Parameters
- models: list
A list of paths of models to use for making model deviation
- system: str
The path of system to make model deviation calculation
- set_prefix: str
The set prefix of the system
- output: str
The output file for model deviation results
- frequency: int
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.
- deepmd.infer.model_devi.write_model_devi_out(devi: numpy.ndarray, fname: str, header: str = '')[source]
- Parameters
- devi
numpy.ndarray the first column is the steps index
- fname
str the file name to dump
- header
str, default=”” the header to dump
- devi
deepmd.loggers package
Module taking care of logging duties.
- deepmd.loggers.set_log_handles(level: int, log_path: Optional[Path] = None, mpi_log: Optional[str] = None)[source]
Set desired level for package loggers and add file handlers.
- Parameters
- level: int
logging level
- log_path: Optional[str]
path to log file, if None logs will be send only to console. If the parent directory does not exist it will be automatically created, by default None
- mpi_log
Optional[str],optional mpi log type. Has three options. master will output logs to file and console only from rank==0. collect will write messages from all ranks to one file opened under rank==0 and to console. workers will open one log file for each worker designated by its rank, console behaviour is the same as for collect. If this argument is specified, package ‘mpi4py’ must be already installed. by default None
- Raises
RuntimeErrorIf the argument mpi_log is specified, package mpi4py is not installed.
Notes
Logging levels:
our notation
python logging
tensorflow cpp
OpenMP
debug
10
10
0
1/on/true/yes
info
20
20
1
0/off/false/no
warning
30
30
2
0/off/false/no
error
40
40
3
0/off/false/no
References
https://groups.google.com/g/mpi4py/c/SaNzc8bdj6U https://stackoverflow.com/questions/35869137/avoid-tensorflow-print-on-standard-error https://stackoverflow.com/questions/56085015/suppress-openmp-debug-messages-when-running-tensorflow-on-cpu
Submodules
deepmd.loggers.loggers module
Logger initialization for package.
- deepmd.loggers.loggers.set_log_handles(level: int, log_path: Optional[Path] = None, mpi_log: Optional[str] = None)[source]
Set desired level for package loggers and add file handlers.
- Parameters
- level: int
logging level
- log_path: Optional[str]
path to log file, if None logs will be send only to console. If the parent directory does not exist it will be automatically created, by default None
- mpi_log
Optional[str],optional mpi log type. Has three options. master will output logs to file and console only from rank==0. collect will write messages from all ranks to one file opened under rank==0 and to console. workers will open one log file for each worker designated by its rank, console behaviour is the same as for collect. If this argument is specified, package ‘mpi4py’ must be already installed. by default None
- Raises
RuntimeErrorIf the argument mpi_log is specified, package mpi4py is not installed.
Notes
Logging levels:
our notation
python logging
tensorflow cpp
OpenMP
debug
10
10
0
1/on/true/yes
info
20
20
1
0/off/false/no
warning
30
30
2
0/off/false/no
error
40
40
3
0/off/false/no
References
https://groups.google.com/g/mpi4py/c/SaNzc8bdj6U https://stackoverflow.com/questions/35869137/avoid-tensorflow-print-on-standard-error https://stackoverflow.com/questions/56085015/suppress-openmp-debug-messages-when-running-tensorflow-on-cpu
deepmd.loss package
Submodules
deepmd.loss.ener module
- class deepmd.loss.ener.EnerDipoleLoss(starter_learning_rate: float, start_pref_e: float = 0.1, limit_pref_e: float = 1.0, start_pref_ed: float = 1.0, limit_pref_ed: float = 1.0)[source]
Bases:
deepmd.loss.loss.LossMethods
build(learning_rate, natoms, model_dict, ...)Build the loss function graph.
eval(sess, feed_dict, natoms)Eval the loss function.
- build(learning_rate, natoms, model_dict, label_dict, suffix)[source]
Build the loss function graph.
- Parameters
- Returns
- class deepmd.loss.ener.EnerStdLoss(starter_learning_rate: float, start_pref_e: float = 0.02, limit_pref_e: float = 1.0, start_pref_f: float = 1000, limit_pref_f: float = 1.0, start_pref_v: float = 0.0, limit_pref_v: float = 0.0, start_pref_ae: float = 0.0, limit_pref_ae: float = 0.0, start_pref_pf: float = 0.0, limit_pref_pf: float = 0.0, relative_f: Optional[float] = None, enable_atom_ener_coeff: bool = False)[source]
Bases:
deepmd.loss.loss.LossStandard loss function for DP models
- Parameters
- enable_atom_ener_coeffbool
if true, the energy will be computed as sum_i c_i E_i
Methods
build(learning_rate, natoms, model_dict, ...)Build the loss function graph.
eval(sess, feed_dict, natoms)Eval the loss function.
- build(learning_rate, natoms, model_dict, label_dict, suffix)[source]
Build the loss function graph.
- Parameters
- Returns
deepmd.loss.loss module
- class deepmd.loss.loss.Loss[source]
Bases:
objectThe abstract class for the loss function.
Methods
build(learning_rate, natoms, model_dict, ...)Build the loss function graph.
eval(sess, feed_dict, natoms)Eval the loss function.
- abstract build(learning_rate: tensorflow.python.framework.ops.Tensor, natoms: tensorflow.python.framework.ops.Tensor, model_dict: Dict[str, tensorflow.python.framework.ops.Tensor], label_dict: Dict[str, tensorflow.python.framework.ops.Tensor], suffix: str) Tuple[tensorflow.python.framework.ops.Tensor, Dict[str, tensorflow.python.framework.ops.Tensor]][source]
Build the loss function graph.
- Parameters
- Returns
deepmd.loss.tensor module
- class deepmd.loss.tensor.TensorLoss(jdata, **kwarg)[source]
Bases:
deepmd.loss.loss.LossLoss function for tensorial properties.
Methods
build(learning_rate, natoms, model_dict, ...)Build the loss function graph.
eval(sess, feed_dict, natoms)Eval the loss function.
- build(learning_rate, natoms, model_dict, label_dict, suffix)[source]
Build the loss function graph.
- Parameters
- Returns
deepmd.model package
Submodules
deepmd.model.ener module
- class deepmd.model.ener.EnerModel(descrpt, fitting, typeebd=None, type_map: Optional[List[str]] = None, data_stat_nbatch: int = 10, data_stat_protect: float = 0.01, use_srtab: Optional[str] = None, smin_alpha: Optional[float] = None, sw_rmin: Optional[float] = None, sw_rmax: Optional[float] = None)[source]
Bases:
deepmd.model.model.ModelEnergy model.
- Parameters
- descrpt
Descriptor
- fitting
Fitting net
- type_map
Mapping atom type to the name (str) of the type. For example type_map[1] gives the name of the type 1.
- data_stat_nbatch
Number of frames used for data statistic
- data_stat_protect
Protect parameter for atomic energy regression
- use_srtab
The table for the short-range pairwise interaction added on top of DP. 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.
- smin_alpha
The short-range tabulated interaction will be swithed according to the distance of the nearest neighbor. This distance is calculated by softmin. This parameter is the decaying parameter in the softmin. It is only required when use_srtab is provided.
- sw_rmin
The lower boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
- sw_rmin
The upper boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
Methods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_rcut
get_type_map
- build(coord_, atype_, natoms, box, mesh, input_dict, frz_model=None, suffix='', reuse=None)[source]
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, model_type: str = 'original_model', suffix: str = '') None[source]
Init the embedding net variables with the given frozen model
- model_type = 'ener'
deepmd.model.model module
- class deepmd.model.model.Model[source]
Bases:
objectMethods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
deepmd.model.model_stat module
- deepmd.model.model_stat.make_stat_input(data, nbatches, merge_sys=True)[source]
pack data for statistics
- Parameters
- data:
The data
- merge_sys: bool (True)
Merge system data
- Returns
- all_stat:
A dictionary of list of list storing data for stat. if merge_sys == False data can be accessed by
all_stat[key][sys_idx][batch_idx][frame_idx]
- else merge_sys == True can be accessed by
all_stat[key][batch_idx][frame_idx]
deepmd.model.multi module
- class deepmd.model.multi.MultiModel(descrpt, fitting_dict, fitting_type_dict, typeebd=None, type_map: Optional[List[str]] = None, data_stat_nbatch: int = 10, data_stat_protect: float = 0.01, use_srtab: Optional[str] = None, smin_alpha: Optional[float] = None, sw_rmin: Optional[float] = None, sw_rmax: Optional[float] = None)[source]
Bases:
deepmd.model.model.ModelMulti-task model.
- Parameters
- descrpt
Descriptor
- fitting_dict
Dictionary of fitting nets
- fitting_type_dict
Dictionary of types of fitting nets
- typeebd
Type embedding net
- type_map
Mapping atom type to the name (str) of the type. For example type_map[1] gives the name of the type 1.
- data_stat_nbatch
Number of frames used for data statistic
- data_stat_protect
Protect parameter for atomic energy regression
- use_srtab
The table for the short-range pairwise interaction added on top of DP. 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.
- smin_alpha
The short-range tabulated interaction will be swithed according to the distance of the nearest neighbor. This distance is calculated by softmin. This parameter is the decaying parameter in the softmin. It is only required when use_srtab is provided.
- sw_rmin
The lower boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
- sw_rmin
The upper boundary of the interpolation between short-range tabulated interaction and DP. It is only required when use_srtab is provided.
Methods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_rcut
get_type_map
- build(coord_, atype_, natoms, box, mesh, input_dict, frz_model=None, suffix='', reuse=None)[source]
- model_type = 'multi-task'
deepmd.model.tensor module
- class deepmd.model.tensor.DipoleModel(*args, **kwargs)[source]
Bases:
deepmd.model.tensor.TensorModelMethods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_out_size
get_rcut
get_sel_type
get_type_map
- class deepmd.model.tensor.GlobalPolarModel(*args, **kwargs)[source]
Bases:
deepmd.model.tensor.TensorModelMethods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_out_size
get_rcut
get_sel_type
get_type_map
- class deepmd.model.tensor.PolarModel(*args, **kwargs)[source]
Bases:
deepmd.model.tensor.TensorModelMethods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_out_size
get_rcut
get_sel_type
get_type_map
- class deepmd.model.tensor.TensorModel(tensor_name: str, descrpt, fitting, typeebd=None, type_map: Optional[List[str]] = None, data_stat_nbatch: int = 10, data_stat_protect: float = 0.01)[source]
Bases:
deepmd.model.model.ModelTensor model.
- Parameters
- tensor_name
Name of the tensor.
- descrpt
Descriptor
- fitting
Fitting net
- typeebd
Type embedding net
- type_map
Mapping atom type to the name (str) of the type. For example type_map[1] gives the name of the type 1.
- data_stat_nbatch
Number of frames used for data statistic
- data_stat_protect
Protect parameter for atomic energy regression
Methods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_out_size
get_rcut
get_sel_type
get_type_map
- build(coord_, atype_, natoms, box, mesh, input_dict, frz_model=None, suffix='', reuse=None)[source]
- class deepmd.model.tensor.WFCModel(*args, **kwargs)[source]
Bases:
deepmd.model.tensor.TensorModelMethods
init_variables(graph, graph_def[, ...])Init the embedding net variables with the given frozen model
build
data_stat
get_ntypes
get_out_size
get_rcut
get_sel_type
get_type_map
deepmd.nvnmd package
Subpackages
- Provides
hardware configuration
default input script
title and citation
- jdata_sys
action configuration
- jdata_config
hardware configuration
- dscp
descriptor configuration
- fitn
fitting network configuration
- size
ram capacity
- ctrl
control flag, such as Time Division Multiplexing (TDM)
- nbit
number of bits of fixed-point number
- jdata_config_16 (disable)
difference with configure fitting size as 16
- jdata_config_32 (disable)
difference with configure fitting size as 32
- jdata_config_64 (disable)
difference with configure fitting size as 64
- jdata_config_128 (default)
difference with configure fitting size as 128
- jdata_configs
all configure of jdata_config{nfit_node}
- jdata_deepmd_input
default input script for nvnmd training
- NVNMD_WELCOME
nvnmd title when logging
- NVNMD_CITATION
citation of nvnmd
- Provides
building descriptor with continuous embedding network
building descriptor with quantized embedding network
- deepmd.nvnmd.descriptor.se_a.build_davg_dstd()[source]
Get the davg and dstd from the dictionary nvnmd_cfg. The davg and dstd have been obtained by training CNN
- class deepmd.nvnmd.entrypoints.MapTable(config_file: str, weight_file: str, map_file: str)[source]
Bases:
objectGenerate the mapping table describing the relastionship of atomic distance, cutoff function, and embedding matrix.
three mapping table will be built:
\(r^2_{ji} \rightarrow s_{ji}\)\(r^2_{ji} \rightarrow sr_{ji}\)\(r^2_{ji} \rightarrow \mathcal{G}_{ji}\)where \(s_{ji}\) is cut-off function, \(sr_{ji} = \frac{s(r_{ji})}{r_{ji}}\), and \(\mathcal{G}_{ji}\) is embedding matrix.
The mapping funciton can be define as:
\(y = f(x) = y_{k} + (x - x_{k}) * dy_{k}\)\(y_{k} = f(x_{k})\)\(dy_{k} = \frac{f(x_{k+1}) - f(x_{k})}{dx}\)\(x_{k} \leq x < x_{k+1}\)\(x_{k} = k * dx\)where \(dx\) is interpolation interval.
- Parameters
- config_file
input file name an .npy file containing the configuration information of NVNMD model
- weight_file
input file name an .npy file containing the weights of NVNMD model
- map_file
output file name an .npy file containing the mapping tables of NVNMD model
References
DOI: 10.1038/s41524-022-00773-z
Methods
build_dG_ds
build_ds_dr
build_map
build_r2s
build_r2s_r2ds
build_s2G
build_s2G_s2dG
qqq
run_s2G
run_u2s
- class deepmd.nvnmd.entrypoints.Wrap(config_file: str, weight_file: str, map_file: str, model_file: str)[source]
Bases:
objectGenerate the binary model file (model.pb) the model file can be use to run the NVNMD with lammps the pair style need set as:
pair_style nvnmd model.pb pair_coeff * *
- Parameters
- config_file
input file name an .npy file containing the configuration information of NVNMD model
- weight_file
input file name an .npy file containing the weights of NVNMD model
- map_file
input file name an .npy file containing the mapping tables of NVNMD model
- model_file
output file name an .pb file containing the model using in the NVNMD
References
DOI: 10.1038/s41524-022-00773-z
Methods
Wrap the configuration of descriptor
Wrap the weights of fitting net
wrap_map()Wrap the mapping table of embedding network
wrap
wrap_bias
wrap_head
wrap_weight
- deepmd.nvnmd.entrypoints.save_weight(sess, file_name: str = 'nvnmd/weight.npy')[source]
Save the dictionary of weight to a npy file
- deepmd.nvnmd.entrypoints.freeze.filter_tensorVariableList(tensorVariableList) dict[source]
Get the name of variable for NVNMD
descrpt_attr/t_avg:0descrpt_attr/t_std:0filter_type_{atom i}/matrix_{layer l}_{atomj}:0filter_type_{atom i}/bias_{layer l}_{atomj}:0layer_{layer l}_type_{atom i}/matrix:0layer_{layer l}_type_{atom i}/bias:0final_layer_type_{atom i}/matrix:0final_layer_type_{atom i}/bias:0
- class deepmd.nvnmd.entrypoints.mapt.MapTable(config_file: str, weight_file: str, map_file: str)[source]
Bases:
objectGenerate the mapping table describing the relastionship of atomic distance, cutoff function, and embedding matrix.
three mapping table will be built:
\(r^2_{ji} \rightarrow s_{ji}\)\(r^2_{ji} \rightarrow sr_{ji}\)\(r^2_{ji} \rightarrow \mathcal{G}_{ji}\)where \(s_{ji}\) is cut-off function, \(sr_{ji} = \frac{s(r_{ji})}{r_{ji}}\), and \(\mathcal{G}_{ji}\) is embedding matrix.
The mapping funciton can be define as:
\(y = f(x) = y_{k} + (x - x_{k}) * dy_{k}\)\(y_{k} = f(x_{k})\)\(dy_{k} = \frac{f(x_{k+1}) - f(x_{k})}{dx}\)\(x_{k} \leq x < x_{k+1}\)\(x_{k} = k * dx\)where \(dx\) is interpolation interval.
- Parameters
- config_file
input file name an .npy file containing the configuration information of NVNMD model
- weight_file
input file name an .npy file containing the weights of NVNMD model
- map_file
output file name an .npy file containing the mapping tables of NVNMD model
References
DOI: 10.1038/s41524-022-00773-z
Methods
build_dG_ds
build_ds_dr
build_map
build_r2s
build_r2s_r2ds
build_s2G
build_s2G_s2dG
qqq
run_s2G
run_u2s
- deepmd.nvnmd.entrypoints.train.normalized_input(fn, PATH_CNN)[source]
Normalize a input script file for continuous neural network
- class deepmd.nvnmd.entrypoints.wrap.Wrap(config_file: str, weight_file: str, map_file: str, model_file: str)[source]
Bases:
objectGenerate the binary model file (model.pb) the model file can be use to run the NVNMD with lammps the pair style need set as:
pair_style nvnmd model.pb pair_coeff * *
- Parameters
- config_file
input file name an .npy file containing the configuration information of NVNMD model
- weight_file
input file name an .npy file containing the weights of NVNMD model
- map_file
input file name an .npy file containing the mapping tables of NVNMD model
- model_file
output file name an .pb file containing the model using in the NVNMD
References
DOI: 10.1038/s41524-022-00773-z
Methods
Wrap the configuration of descriptor
Wrap the weights of fitting net
wrap_map()Wrap the mapping table of embedding network
wrap
wrap_bias
wrap_head
wrap_weight
- Provides
continuous fitting network
quantized fitting network
- class deepmd.nvnmd.utils.Encode[source]
Bases:
objectEncoding value as hex, bin, and dec format
Methods
bin2hex(data)Convert binary string list to hex string list
bin2hex_str(sbin)Convert binary string to hex string
check_dec(idec, nbit[, signed, name])Check whether the data (idec) is in the range range is \([0, 2^nbit-1]\) for unsigned range is \([-2^{nbit-1}, 2^{nbit-1}-1]\) for signed
dec2bin(idec[, nbit, signed, name])Convert dec array to binary string list
extend_bin(slbin, nfull)Extend the element of list (slbin) to the length (nfull)
extend_hex(slhex, nfull)Extend the element of list (slhex) to the length (nfull)
extend_list(slbin, nfull)Extend the list (slbin) to the length (nfull) the attched element of list is 0
hex2bin(data)Convert hex string list to binary string list
hex2bin_str(shex)Convert hex string to binary string
merge_bin(slbin, nmerge)Merge binary string list per nmerge value
qc(v[, nbit])Quantize value using ceil
qf(v[, nbit])Quantize value using floor
qr(v[, nbit])Quantize value using round
reverse_bin(slbin, nreverse)Reverse binary string list per nreverse value
split_bin(sbin, nbit)Split sbin into many segment with the length nbit
- check_dec(idec, nbit, signed=False, name='')[source]
Check whether the data (idec) is in the range range is \([0, 2^nbit-1]\) for unsigned range is \([-2^{nbit-1}, 2^{nbit-1}-1]\) for signed
- extend_bin(slbin, nfull)[source]
Extend the element of list (slbin) to the length (nfull)
such as, when
slbin = [‘10010’,’10100’],nfull = 6extent to
[‘010010’,’010100’]
- class deepmd.nvnmd.utils.FioBin[source]
Bases:
objectInput and output for binary file
Methods
load([file_name, default_value])Load binary file into bytes value
save(file_name, data)Save hex string into binary file
- class deepmd.nvnmd.utils.FioDic[source]
Bases:
objectInput and output for dict class data the file can be .json or .npy file containing a dictionary
Methods
update(jdata, jdata_o)Update key-value pair is key in jdata_o.keys()
get
load
save
- class deepmd.nvnmd.utils.FioTxt[source]
Bases:
objectInput and output for .txt file with string
Methods
load([file_name, default_value])Load .txt file into string list
save([file_name, data])Save string list into .txt file
- deepmd.nvnmd.utils.get_filter_weight(weights: dict, spe_i: int, spe_j: int, layer_l: int)[source]
Get weight and bias of embedding network
- Parameters
- spe_i(int)
special order of central atom i 0~ntype-1
- spe_j(int)
special order of neighbor atom j 0~ntype-1
- layer_l
layer order in embedding network 1~nlayer
- deepmd.nvnmd.utils.get_fitnet_weight(weights: dict, spe_i: int, layer_l: int, nlayer: int = 10)[source]
Get weight and bias of fitting network
- Parameters
- spe_i(int)
special order of central atom i 0~ntype-1
- layer_l(int)
layer order in embedding network 0~nlayer-1
- deepmd.nvnmd.utils.map_nvnmd(x, map_y, map_dy, prec, nbit=None)[source]
Mapping function implemented by numpy
- deepmd.nvnmd.utils.one_layer(inputs, outputs_size, activation_fn=<function tanh>, precision=tf.float64, stddev=1.0, bavg=0.0, name='linear', reuse=None, seed=None, use_timestep=False, trainable=True, useBN=False, uniform_seed=False, initial_variables=None, mixed_prec=None, final_layer=False)[source]
Build one layer with continuous or quantized value. Its weight and bias can be initialed with random or constant value.
- class deepmd.nvnmd.utils.config.NvnmdConfig(jdata: dict)[source]
Bases:
objectConfiguration for NVNMD record the message of model such as size, using nvnmd or not
- Parameters
- jdata
a dictionary of input script
References
DOI: 10.1038/s41524-022-00773-z
Methods
Display the log of NVNMD
Generate input script with member element one by one
Generate model/descriptor in input script
Generate model/fitting_net in input script
Generate learning_rate in input script
Generate loss in input script
Generate model in input script
Generate nvnmd in input script
Generate training in input script
init_ctrl(jdata[, jdata_parent])Initial members about control signal
init_dscp(jdata[, jdata_parent])Initial members about descriptor
init_fitn(jdata[, jdata_parent])Initial members about fitting network
init_from_config(jdata)Initial member element one by one
init_from_deepmd_input(jdata)Initial members with input script of deepmd
init_from_jdata([jdata])Initial this class with jdata loaded from input script
init_nbit(jdata[, jdata_parent])Initial members about quantification precision
Initial net_size
init_size(jdata[, jdata_parent])Initial members about ram capacity
init_train_mode([mod])Configure for taining cnn or qnn
Initial member with dict
save([file_name])Save all configuration to file
- class deepmd.nvnmd.utils.encode.Encode[source]
Bases:
objectEncoding value as hex, bin, and dec format
Methods
bin2hex(data)Convert binary string list to hex string list
bin2hex_str(sbin)Convert binary string to hex string
check_dec(idec, nbit[, signed, name])Check whether the data (idec) is in the range range is \([0, 2^nbit-1]\) for unsigned range is \([-2^{nbit-1}, 2^{nbit-1}-1]\) for signed
dec2bin(idec[, nbit, signed, name])Convert dec array to binary string list
extend_bin(slbin, nfull)Extend the element of list (slbin) to the length (nfull)
extend_hex(slhex, nfull)Extend the element of list (slhex) to the length (nfull)
extend_list(slbin, nfull)Extend the list (slbin) to the length (nfull) the attched element of list is 0
hex2bin(data)Convert hex string list to binary string list
hex2bin_str(shex)Convert hex string to binary string
merge_bin(slbin, nmerge)Merge binary string list per nmerge value
qc(v[, nbit])Quantize value using ceil
qf(v[, nbit])Quantize value using floor
qr(v[, nbit])Quantize value using round
reverse_bin(slbin, nreverse)Reverse binary string list per nreverse value
split_bin(sbin, nbit)Split sbin into many segment with the length nbit
- check_dec(idec, nbit, signed=False, name='')[source]
Check whether the data (idec) is in the range range is \([0, 2^nbit-1]\) for unsigned range is \([-2^{nbit-1}, 2^{nbit-1}-1]\) for signed
- extend_bin(slbin, nfull)[source]
Extend the element of list (slbin) to the length (nfull)
such as, when
slbin = [‘10010’,’10100’],nfull = 6extent to
[‘010010’,’010100’]
- class deepmd.nvnmd.utils.fio.Fio[source]
Bases:
objectBasic class for FIO
Methods
create_file_path
exits
get_file_list
is_file
is_path
mkdir
- class deepmd.nvnmd.utils.fio.FioBin[source]
Bases:
objectInput and output for binary file
Methods
load([file_name, default_value])Load binary file into bytes value
save(file_name, data)Save hex string into binary file
- class deepmd.nvnmd.utils.fio.FioDic[source]
Bases:
objectInput and output for dict class data the file can be .json or .npy file containing a dictionary
Methods
update(jdata, jdata_o)Update key-value pair is key in jdata_o.keys()
get
load
save
- class deepmd.nvnmd.utils.fio.FioJsonDic[source]
Bases:
objectInput and output for .json file containing dictionary
Methods
load([file_name, default_value])Load .json file into dict
save([file_name, dic])Save dict into .json file
- class deepmd.nvnmd.utils.fio.FioNpyDic[source]
Bases:
objectInput and output for .npy file containing dictionary
Methods
load
save
- deepmd.nvnmd.utils.network.matmul2_qq(a, b, nbit)[source]
Quantized matmul operation for 2d tensor. a and b is input tensor, nbit represent quantification precision
- deepmd.nvnmd.utils.network.matmul3_qq(a, b, nbit)[source]
Quantized matmul operation for 3d tensor. a and b is input tensor, nbit represent quantification precision
- deepmd.nvnmd.utils.network.one_layer(inputs, outputs_size, activation_fn=<function tanh>, precision=tf.float64, stddev=1.0, bavg=0.0, name='linear', reuse=None, seed=None, use_timestep=False, trainable=True, useBN=False, uniform_seed=False, initial_variables=None, mixed_prec=None, final_layer=False)[source]
Build one layer with continuous or quantized value. Its weight and bias can be initialed with random or constant value.
- deepmd.nvnmd.utils.network.one_layer_wb(shape, outputs_size, bavg, stddev, precision, trainable, initial_variables, seed, uniform_seed, name)[source]
- deepmd.nvnmd.utils.network.qf(x, nbit)[source]
Quantize and floor tensor x with quantification precision nbit.
- deepmd.nvnmd.utils.network.qr(x, nbit)[source]
Quantize and round tensor x with quantification precision nbit.
- deepmd.nvnmd.utils.weight.get_constant_initializer(weights, name)[source]
Get initial value by name and create a initializer
- deepmd.nvnmd.utils.weight.get_filter_weight(weights: dict, spe_i: int, spe_j: int, layer_l: int)[source]
Get weight and bias of embedding network
- Parameters
- spe_i(int)
special order of central atom i 0~ntype-1
- spe_j(int)
special order of neighbor atom j 0~ntype-1
- layer_l
layer order in embedding network 1~nlayer
- deepmd.nvnmd.utils.weight.get_fitnet_weight(weights: dict, spe_i: int, layer_l: int, nlayer: int = 10)[source]
Get weight and bias of fitting network
- Parameters
- spe_i(int)
special order of central atom i 0~ntype-1
- layer_l(int)
layer order in embedding network 0~nlayer-1
deepmd.op package
This module will house cust Tf OPs after CMake installation.
deepmd.train package
Submodules
deepmd.train.run_options module
Module taking care of important package constants.
- class deepmd.train.run_options.RunOptions(init_model: Optional[str] = None, init_frz_model: Optional[str] = None, finetune: Optional[str] = None, restart: Optional[str] = None, log_path: Optional[str] = None, log_level: int = 0, mpi_log: str = 'master')[source]
Bases:
objectClass with inf oon how to run training (cluster, MPI and GPU config).
- Attributes
- gpus: Optional[List[int]]
list of GPUs if any are present else None
- is_chief: bool
in distribured training it is true for tha main MPI process in serail it is always true
- world_size: int
total worker count
- my_rank: int
index of the MPI task
- nodename: str
name of the node
- node_list_
List[str] the list of nodes of the current mpirun
- my_device: str
deviice type - gpu or cpu
Methods
Print build and current running cluster configuration summary.
- property is_chief
Whether my rank is 0.
deepmd.train.trainer module
- class deepmd.train.trainer.DPTrainer(jdata, run_opt, is_compress=False)[source]
Bases:
objectMethods
Save the compressed graph
build
eval_single_list
get_evaluation_results
get_feed_dict
get_global_step
print_header
print_on_training
save_checkpoint
train
valid_on_the_fly
deepmd.utils package
Submodules
deepmd.utils.argcheck module
- class deepmd.utils.argcheck.ArgsPlugin[source]
Bases:
objectMethods
get_all_argument([exclude_hybrid])Get all arguments.
register(name[, alias])Regiester a descriptor argument plugin.
- get_all_argument(exclude_hybrid: bool = False) List[dargs.dargs.Argument][source]
Get all arguments.
- deepmd.utils.argcheck.descrpt_variant_type_args(exclude_hybrid: bool = False) dargs.dargs.Variant[source]
deepmd.utils.batch_size module
- class deepmd.utils.batch_size.AutoBatchSize(initial_batch_size: int = 1024, factor: float = 2.0)[source]
Bases:
objectThis class allows DeePMD-kit to automatically decide the maximum batch size that will not cause an OOM error.
- Parameters
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
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) Tuple[int, tuple][source]
Excuate a method with given batch size.
- Parameters
- Returns
- Raises
OutOfMemoryErrorOOM when batch size is 1
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: Optional[Union[str, pathlib.Path]] = None) Dict[str, Any][source]
Convert input from v0 format to v1.
- deepmd.utils.compat.convert_input_v1_v2(jdata: Dict[str, Any], warning: bool = True, dump: Optional[Union[str, pathlib.Path]] = None) Dict[str, Any][source]
- deepmd.utils.compat.deprecate_numb_test(jdata: Dict[str, Any], warning: bool = True, dump: Optional[Union[str, pathlib.Path]] = None) Dict[str, Any][source]
Deprecate numb_test since v2.1. It has taken no effect since v2.0.
See #1243.
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.
- deepmd.utils.convert.convert_10_to_21(input_model: str, output_model: str)[source]
Convert DP 1.0 graph to 2.1 graph.
- deepmd.utils.convert.convert_12_to_21(input_model: str, output_model: str)[source]
Convert DP 1.2 graph to 2.1 graph.
- deepmd.utils.convert.convert_13_to_21(input_model: str, output_model: str)[source]
Convert DP 1.3 graph to 2.1 graph.
- deepmd.utils.convert.convert_20_to_21(input_model: str, output_model: str)[source]
Convert DP 2.0 graph to 2.1 graph.
- deepmd.utils.convert.convert_dp012_to_dp10(file: str)[source]
Convert DP 0.12 graph text to 1.0 graph text.
- Parameters
- file
str filename of the graph text
- file
- deepmd.utils.convert.convert_dp10_to_dp11(file: str)[source]
Convert DP 1.0 graph text to 1.1 graph text.
- Parameters
- file
str filename of the graph text
- file
- deepmd.utils.convert.convert_dp12_to_dp13(file: str)[source]
Convert DP 1.2 graph text to 1.3 graph text.
- Parameters
- file
str filename of the graph text
- file
- deepmd.utils.convert.convert_dp13_to_dp20(fname: str)[source]
Convert DP 1.3 graph text to 2.0 graph text.
- Parameters
- file
str filename of the graph text
- file
deepmd.utils.data module
- class deepmd.utils.data.DeepmdData(sys_path: str, set_prefix: str = 'set', shuffle_test: bool = True, type_map: Optional[List[str]] = None, optional_type_map: bool = True, modifier=None, trn_all_set: bool = False)[source]
Bases:
objectClass 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: Optional[List[int]] = None, repeat: int = 1, default: float = 0.0)[source]
Add a data item that to be loaded
- 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
float, default=0. default value of data
- 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_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_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
natomsnatoms[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_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.
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: Optional[List[str]] = None, optional_type_map: bool = True, modifier=None, trn_all_set=False, sys_probs=None, auto_prob_style='prob_sys_size')[source]
Bases:
objectClass 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 the batch size
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,
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: Optional[List[int]] = None, repeat: int = 1, default: float = 0.0)[source]
Add a data item that to be loaded
- 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_dict(adict: dict) None[source]
Add items to the data system by a dict. adict should have items like .. code-block:: python
- adict[key] = {
‘ndof’: ndof, ‘atomic’: atomic, ‘must’: must, ‘high_prec’: high_prec, ‘type_sel’: type_sel, ‘repeat’: repeat,
}
For the explaination of the keys see add
- get_batch(sys_idx: Optional[int] = None)[source]
Get a batch of data from the data systems
- Parameters
- sys_idx: int
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.
- get_sys(idx: int) deepmd.utils.data.DeepmdData[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: Optional[int] = 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.
deepmd.utils.errors module
deepmd.utils.finetune module
deepmd.utils.graph module
- deepmd.utils.graph.get_attention_layer_nodes_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the attention layer nodes with the given tf.GraphDef object
- deepmd.utils.graph.get_attention_layer_variables_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the attention layer variables with 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)
- deepmd.utils.graph.get_embedding_net_nodes_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the embedding net nodes with 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)
- deepmd.utils.graph.get_embedding_net_variables_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the embedding net variables with 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
DictThe fitting net nodes with the given frozen model
- deepmd.utils.graph.get_fitting_net_nodes_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.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
DictThe 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
DictThe fitting net variables within the given frozen model
- deepmd.utils.graph.get_fitting_net_variables_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.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
DictThe fitting net variables within the given tf.GraphDef object
- deepmd.utils.graph.get_pattern_nodes_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.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
DictThe fitting net nodes within the given tf.GraphDef object
- deepmd.utils.graph.get_tensor_by_name(model_file: str, tensor_name: str) tensorflow.python.framework.ops.Tensor[source]
Load tensor value from the frozen model(model_file)
- deepmd.utils.graph.get_tensor_by_name_from_graph(graph: tensorflow.python.framework.ops.Graph, tensor_name: str) tensorflow.python.framework.ops.Tensor[source]
Load tensor value from the given tf.Graph object
- deepmd.utils.graph.get_tensor_by_type(node, data_type: numpy.dtype) tensorflow.python.framework.ops.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.TensorThe tensor value of the given node
- deepmd.utils.graph.get_type_embedding_net_nodes_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the type embedding net nodes with the given tf.GraphDef object
- deepmd.utils.graph.get_type_embedding_net_variables_from_graph_def(graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix: str = '') Dict[source]
Get the type embedding net variables with the given tf.GraphDef object
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:
objectThe 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
start_lr()Get the start lr
value(step)Get the lr at a certain step
- build(global_step: tensorflow.python.framework.ops.Tensor, stop_step: Optional[int] = None) tensorflow.python.framework.ops.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_rateThe learning rate
deepmd.utils.neighbor_stat module
- class deepmd.utils.neighbor_stat.NeighborStat(ntypes: int, rcut: float, one_type: bool = False)[source]
Bases:
objectClass 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
The cut-off radius
- 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: deepmd.utils.data_system.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_distThe nearest distance between neighbor atoms
max_nbor_sizeA 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
- xx
Tensor Input tensor \(\mathbf{x}\) of shape [-1,1]
- network_size: list 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_dt: boolean
Using time-step in the ResNet construction
- name_suffix: str
The name suffix append to each variable.
- stddev: float
Standard deviation of initializing network parameters
- bavg: float
Mean of network intial bias
- seed: int
Random seed for initializing network parameters
- trainable: boolean
If the network is trainable
- uniform_seedbool
Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed
- initial_variables
dict The input dict which stores the embedding net variables
- mixed_prec
The input dict which stores the mixed precision setting for the embedding net
- xx
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.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.variable_summaries(var: tensorflow.python.ops.variables.VariableV1, name: str)[source]
Attach a lot of summaries to a Tensor (for TensorBoard visualization).
- Parameters
- var
tf.Variable [description]
- name
str variable name
- var
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()Get the serialized table.
reinit(filename)Initialize the tabulated interaction
- 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, tensorflow.python.framework.ops.Tensor], Tuple[tensorflow.python.framework.ops.Tensor]]], nthreads: Optional[int] = None, config: Optional[tensorflow.core.protobuf.config_pb2.ConfigProto] = None)[source]
Bases:
objectRun an op with data parallelism.
- Parameters
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) ... >>> p = ParallelOp(builder, nthreads=4) >>> 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.
deepmd.utils.path module
- class deepmd.utils.path.DPH5Path(path: str)[source]
Bases:
deepmd.utils.path.DPPathThe path class to data system (DeepmdData) for HDF5 files.
- Parameters
- path
str path
- path
Notes
- OS - HDF5 relationship:
directory - Group file - Dataset
Methods
glob(pattern)Search path using the glob pattern.
is_dir()Check if self is directory.
is_file()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) List[deepmd.utils.path.DPPath][source]
Search path using the glob pattern.
- load_numpy() numpy.ndarray[source]
Load NumPy array.
- Returns
np.ndarrayloaded NumPy array
- load_txt(dtype: Optional[numpy.dtype] = None, **kwargs) numpy.ndarray[source]
Load NumPy array from text.
- Returns
np.ndarrayloaded NumPy array
- rglob(pattern: str) List[deepmd.utils.path.DPPath][source]
This is like calling
DPPath.glob()with **/ added in front of the given relative pattern.
- class deepmd.utils.path.DPOSPath(path: str)[source]
Bases:
deepmd.utils.path.DPPathThe OS path class to data system (DeepmdData) for real directories.
- Parameters
- path
str path
- path
Methods
glob(pattern)Search path using the glob pattern.
is_dir()Check if self is directory.
is_file()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) List[deepmd.utils.path.DPPath][source]
Search path using the glob pattern.
- load_numpy() numpy.ndarray[source]
Load NumPy array.
- Returns
np.ndarrayloaded NumPy array
- load_txt(**kwargs) numpy.ndarray[source]
Load NumPy array from text.
- Returns
np.ndarrayloaded NumPy array
- rglob(pattern: str) List[deepmd.utils.path.DPPath][source]
This is like calling
DPPath.glob()with **/ added in front of the given relative pattern.
- class deepmd.utils.path.DPPath(path: str)[source]
Bases:
abc.ABCThe path class to data system (DeepmdData).
- Parameters
- path
str path
- path
Methods
glob(pattern)Search path using the glob pattern.
is_dir()Check if self is directory.
is_file()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) List[deepmd.utils.path.DPPath][source]
Search path using the glob pattern.
- abstract load_numpy() numpy.ndarray[source]
Load NumPy array.
- Returns
np.ndarrayloaded NumPy array
- abstract load_txt(**kwargs) numpy.ndarray[source]
Load NumPy array from text.
- Returns
np.ndarrayloaded NumPy array
- abstract rglob(pattern: str) List[deepmd.utils.path.DPPath][source]
This is like calling
DPPath.glob()with **/ added in front of the given relative pattern.
deepmd.utils.plugin module
Base of plugin systems.
- class deepmd.utils.plugin.Plugin[source]
Bases:
objectA class to register and restore plugins.
Examples
>>> plugin = Plugin() >>> @plugin.register("xx") def xxx(): pass >>> print(plugin.plugins['xx'])
Methods
get_plugin(key)Visit a plugin by key.
register(key)Register a plugin.
- class deepmd.utils.plugin.PluginVariant(*args, **kwargs)[source]
Bases:
objectA class to remove type from input arguments.
- class deepmd.utils.plugin.VariantABCMeta(name, bases, namespace, **kwargs)[source]
Bases:
deepmd.utils.plugin.VariantMeta,abc.ABCMetaMethods
__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.
deepmd.utils.random module
- deepmd.utils.random.choice(a: numpy.ndarray, p: Optional[numpy.ndarray] = None)[source]
Generates a random sample from a given 1-D array.
- Parameters
- a
np.ndarray A random sample is generated from its elements.
- p
np.ndarray The probabilities associated with each entry in a.
- a
- Returns
np.ndarrayarrays 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.ndarrayArrays with results and their shapes.
- deepmd.utils.random.seed(val: Optional[int] = None)[source]
Seed the generator.
- Parameters
- val
int Seed.
- val
- deepmd.utils.random.shuffle(x: numpy.ndarray)[source]
Modify a sequence in-place by shuffling its contents.
- Parameters
- x
np.ndarray The array or list to be shuffled.
- x
deepmd.utils.sess module
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:
objectClass 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}\)
- graph
tf.Graph The graph of the original model
- graph_def
tf.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
List[List[int]] 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.
- suffix
str,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
- neuron
Number of neurons in each hidden layers of the embedding net \(\mathcal{N}\)
- Returns
deepmd.utils.type_embed module
- class deepmd.utils.type_embed.TypeEmbedNet(neuron: List[int] = [], resnet_dt: bool = False, activation_function: Optional[str] = 'tanh', precision: str = 'default', trainable: bool = True, seed: Optional[int] = None, uniform_seed: bool = False, padding: bool = False)[source]
Bases:
object- Parameters
- neuron
list[int] 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”.
- 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
- padding
Concat the zero padding to the output, as the default embedding of empty type.
- neuron
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_typesThe computational graph for embedded types
- init_variables(graph: tensorflow.python.framework.ops.Graph, graph_def: tensorflow.core.framework.graph_pb2.GraphDef, suffix='') None[source]
Init the type embedding net variables with the given dict
- Parameters
- graph
tf.Graph The input frozen model graph
- graph_def
tf.GraphDef The input frozen model graph_def
- suffix
Name suffix to identify this descriptor
- graph
- deepmd.utils.type_embed.embed_atom_type(ntypes: int, natoms: tensorflow.python.framework.ops.Tensor, type_embedding: tensorflow.python.framework.ops.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_embeddingThe embedded type of each atom. It has the shape of [numb_atoms, embedding_dim]
deepmd.utils.weight_avg module
Submodules
deepmd.calculator module
ASE calculator interface module.
- class deepmd.calculator.DP(model: Union[str, pathlib.Path], label: str = 'DP', type_dict: Optional[Dict[str, int]] = None, **kwargs)[source]
Bases:
ase.calculators.calculator.CalculatorImplementation of ASE deepmd calculator.
Implemented propertie are energy, forces and stress
- Parameters
Examples
Compute potential energy
>>> from ase import Atoms >>> from deepmd.calculator import DP >>> water = Atoms('H2O', >>> positions=[(0.7601, 1.9270, 1), >>> (1.9575, 1, 1), >>> (1., 1., 1.)], >>> cell=[100, 100, 100], >>> calculator=DP(model="frozen_model.pb")) >>> print(water.get_potential_energy()) >>> print(water.get_forces())
Run BFGS structure optimization
>>> from ase.optimize import BFGS >>> dyn = BFGS(water) >>> dyn.run(fmax=1e-6) >>> print(water.get_positions())
- Attributes
- directory
- label
Methods
band_structure()Create band-structure object for plotting.
calculate([atoms, properties, system_changes])Run calculation with deepmd model.
calculate_numerical_forces(atoms[, d])Calculate numerical forces using finite difference.
calculate_numerical_stress(atoms[, d, voigt])Calculate numerical stress using finite difference.
calculate_properties(atoms, properties)This method is experimental; currently for internal use.
check_state(atoms[, tol])Check for any system changes since last calculation.
get_magnetic_moments([atoms])Calculate magnetic moments projected onto atoms.
get_property(name[, atoms, allow_calculation])Get the named property.
get_stresses([atoms])the calculator should return intensive stresses, i.e., such that stresses.sum(axis=0) == stress
read(label)Read atoms, parameters and calculated properties from output file.
reset()Clear all information from old calculation.
set(**kwargs)Set parameters like set(key1=value1, key2=value2, ...).
set_label(label)Set label and convert label to directory and prefix.
calculation_required
export_properties
get_atoms
get_charges
get_default_parameters
get_dipole_moment
get_forces
get_magnetic_moment
get_potential_energies
get_potential_energy
get_stress
read_atoms
todict
- calculate(atoms: Optional[Atoms] = None, properties: List[str] = ['energy', 'forces', 'virial'], system_changes: List[str] = ['positions', 'numbers', 'cell', 'pbc', 'initial_charges', 'initial_magmoms'])[source]
Run calculation with deepmd model.
- Parameters
- atoms
Optional[Atoms],optional atoms object to run the calculation on, by default None
- properties
List[str],optional unused, only for function signature compatibility, by default [“energy”, “forces”, “stress”]
- system_changes
List[str],optional unused, only for function signature compatibility, by default all_changes
- atoms
- implemented_properties: List[str] = ['energy', 'free_energy', 'forces', 'virial', 'stress']
Properties calculator can handle (energy, forces, …)
- name = 'DP'
deepmd.common module
Collection of functions and classes used throughout the whole package.
- deepmd.common.add_data_requirement(key: str, ndof: int, atomic: bool = False, must: bool = False, high_prec: bool = False, type_sel: Optional[bool] = None, repeat: int = 1, default: float = 0.0)[source]
Specify data requirements for training.
- Parameters
- key
str type of data stored in corresponding *.npy file e.g. forces or energy
- ndof
int number of the degrees of freedom, this is tied to atomic parameter e.g. forces have atomic=True and ndof=3
- atomicbool,
optional specifies whwther the ndof keyworrd applies to per atom quantity or not, by default False
- mustbool,
optional specifi if the *.npy data file must exist, by default False
- high_precbool,
optional if tru load data to np.float64 else np.float32, by default False
- type_selbool,
optional select only certain type of atoms, by default None
- repeat
int,optional if specify repaeat data repeat times, by default 1
- default
float,optional, default=0. default value of data
- key
- deepmd.common.cast_precision(func: Callable) Callable[source]
A decorator that casts and casts back the input and output tensor of a method.
The decorator should be used in a classmethod.
The decorator will do the following thing: (1) It casts input Tensors from GLOBAL_TF_FLOAT_PRECISION to precision defined by property precision. (2) It casts output Tensors from precision to GLOBAL_TF_FLOAT_PRECISION. (3) It checks inputs and outputs and only casts when input or output is a Tensor and its dtype matches GLOBAL_TF_FLOAT_PRECISION and precision, respectively. If it does not match (e.g. it is an integer), the decorator will do nothing on it.
- Returns
Callablea decorator that casts and casts back the input and output tensor of a method
Examples
>>> class A: ... @property ... def precision(self): ... return tf.float32 ... ... @cast_precision ... def f(x: tf.Tensor, y: tf.Tensor) -> tf.Tensor: ... return x ** 2 + y
- deepmd.common.expand_sys_str(root_dir: Union[str, pathlib.Path]) List[str][source]
Recursively iterate over directories taking those that contain type.raw file.
- deepmd.common.gelu(x: tensorflow.python.framework.ops.Tensor) tensorflow.python.framework.ops.Tensor[source]
Gaussian Error Linear Unit.
This is a smoother version of the RELU, implemented by custom operator.
- Parameters
- x
tf.Tensor float Tensor to perform activation
- x
- Returns
tf.Tensorx with the GELU activation applied
References
Original paper https://arxiv.org/abs/1606.08415
- deepmd.common.gelu_tf(x: tensorflow.python.framework.ops.Tensor) tensorflow.python.framework.ops.Tensor[source]
Gaussian Error Linear Unit.
This is a smoother version of the RELU, implemented by TF.
- Parameters
- x
tf.Tensor float Tensor to perform activation
- x
- Returns
tf.Tensorx with the GELU activation applied
References
Original paper https://arxiv.org/abs/1606.08415
- deepmd.common.get_activation_func(activation_fn: Optional[_ACTIVATION]) Optional[Callable[[tensorflow.python.framework.ops.Tensor], tensorflow.python.framework.ops.Tensor]][source]
Get activation function callable based on string name.
- Parameters
- activation_fn
_ACTIVATION one of the defined activation functions
- activation_fn
- Returns
- Raises
RuntimeErrorif unknown activation function is specified
- deepmd.common.get_np_precision(precision: _PRECISION) numpy.dtype[source]
Get numpy precision constant from string.
- Parameters
- precision
_PRECISION string name of numpy constant or default
- precision
- Returns
np.dtypenumpy presicion constant
- Raises
RuntimeErrorif string is invalid
- deepmd.common.get_precision(precision: _PRECISION) Any[source]
Convert str to TF DType constant.
- Parameters
- precision
_PRECISION one of the allowed precisions
- precision
- Returns
tf.python.framework.dtypes.DTypeappropriate TF constant
- Raises
RuntimeErrorif supplied precision string does not have acorresponding TF constant
- deepmd.common.j_loader(filename: Union[str, pathlib.Path]) Dict[str, Any][source]
Load yaml or json settings file.
- deepmd.common.j_must_have(jdata: Dict[str, _DICT_VAL], key: str, deprecated_key: List[str] = []) _DICT_VAL[source]
Assert that supplied dictionary conaines specified key.
- Returns
_DICT_VALvalue that was store unde supplied key
- Raises
RuntimeErrorif the key is not present
- deepmd.common.make_default_mesh(test_box: numpy.ndarray, cell_size: float = 3.0) numpy.ndarray[source]
Get number of cells of size=`cell_size` fit into average box.
- Parameters
- test_box
np.ndarray numpy array with cells of shape Nx9
- cell_size
float,optional length of one cell, by default 3.0
- test_box
- Returns
np.ndarraymesh for supplied boxes, how many cells fit in each direction
- deepmd.common.safe_cast_tensor(input: tensorflow.python.framework.ops.Tensor, from_precision: tensorflow.python.framework.dtypes.DType, to_precision: tensorflow.python.framework.dtypes.DType) tensorflow.python.framework.ops.Tensor[source]
Convert a Tensor from a precision to another precision.
If input is not a Tensor or without the specific precision, the method will not cast it.
- Parameters
- input: tf.Tensor
input tensor
- precision
tf.DType Tensor data type that casts to
- Returns
tf.Tensorcasted Tensor
- deepmd.common.select_idx_map(atom_types: numpy.ndarray, select_types: numpy.ndarray) numpy.ndarray[source]
Build map of indices for element supplied element types from all atoms list.
- Parameters
- atom_types
np.ndarray array specifing type for each atoms as integer
- select_types
np.ndarray types of atoms you want to find indices for
- atom_types
- Returns
np.ndarrayindices of types of atoms defined by select_types in atom_types array
Warning
select_types array will be sorted before finding indices in atom_types
deepmd.env module
Module that sets tensorflow working environment and exports inportant constants.
- deepmd.env.GLOBAL_ENER_FLOAT_PRECISION
alias of
numpy.float64
- deepmd.env.GLOBAL_NP_FLOAT_PRECISION
alias of
numpy.float64
- deepmd.env.global_cvt_2_ener_float(xx: tensorflow.python.framework.ops.Tensor) tensorflow.python.framework.ops.Tensor[source]
Cast tensor to globally set energy precision.
deepmd.lmp module
OP API
op_module
Python wrappers around TensorFlow ops.
This file is MACHINE GENERATED! Do not edit.
- deepmd.env.op_module.Descrpt(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, sel_a, sel_r, axis_rule, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
sel_a – A list of ints.
sel_r – A list of ints.
axis_rule – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist, axis, rot_mat).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32. axis: A Tensor of type int32. rot_mat: A Tensor. Has the same type as coord.
- deepmd.env.op_module.DescrptNorot(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.DescrptSeA(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.DescrptSeAEf(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.DescrptSeAEfPara(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.DescrptSeAEfVert(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.DescrptSeR(coord, type, natoms, box, mesh, davg, dstd, rcut, rcut_smth, sel, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut – A float.
rcut_smth – A float.
sel – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.EwaldRecp(coord, charge, natoms, box, ewald_beta, ewald_h, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
charge – A Tensor. Must have the same type as coord.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
ewald_beta – A float.
ewald_h – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (energy, force, virial).
energy: A Tensor. Has the same type as coord. force: A Tensor. Has the same type as coord. virial: A Tensor. Has the same type as coord.
- deepmd.env.op_module.Gelu(x, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.GeluCustom(x, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.GeluGrad(dy, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.GeluGradCustom(dy, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.GeluGradGrad(dy, dy_, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as dy.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.GeluGradGradCustom(dy, dy_, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as dy.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.MapAparam(aparam, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
aparam – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as aparam.
- deepmd.env.op_module.MapNvnmd(x, v, dv, grad_v, grad_dv, prec, nbit, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
v – A Tensor. Must have the same type as x.
dv – A Tensor. Must have the same type as x.
grad_v – A Tensor. Must have the same type as x.
grad_dv – A Tensor. Must have the same type as x.
prec – A float.
nbit – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.MatmulNvnmd(x, w, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as x.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.NeighborStat(coord, type, natoms, box, mesh, rcut, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
rcut – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (max_nbor_size, min_nbor_dist).
max_nbor_size: A Tensor of type int32. min_nbor_dist: A Tensor. Has the same type as coord.
- deepmd.env.op_module.PairTab(table_info, table_data, type, rij, nlist, natoms, scale, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
table_info – A Tensor of type float64.
table_data – A Tensor of type float64.
type – A Tensor of type int32.
rij – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
scale – A Tensor. Must have the same type as rij.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (atom_energy, force, atom_virial).
atom_energy: A Tensor. Has the same type as rij. force: A Tensor. Has the same type as rij. atom_virial: A Tensor. Has the same type as rij.
- deepmd.env.op_module.ParallelProdForceSeA(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, parallel=False, start_frac=0, end_frac=1, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
parallel – An optional bool. Defaults to False.
start_frac – An optional float. Defaults to 0.
end_frac – An optional float. Defaults to 1.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdEnvMatA(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
Compute the environment matrix for descriptor se_e2_a.
Each row of the environment matrix \(\mathcal{R}^i\) can be constructed as follows
\[(\mathcal{R}^i)_j = [ \begin{array}{c} s(r_{ji}) & \frac{s(r_{ji})x_{ji}}{r_{ji}} & \frac{s(r_{ji})y_{ji}}{r_{ji}} & \frac{s(r_{ji})z_{ji}}{r_{ji}} \end{array} ]\]In the above equation, \(\mathbf{R}_{ji}=\mathbf{R}_j-\mathbf{R}_i = (x_{ji}, y_{ji}, z_{ji})\) is the relative coordinate and \(r_{ji}=\lVert \mathbf{R}_{ji} \lVert\) is its norm. The switching function \(s(r)\) is defined as:
\[\begin{split}s(r)= \begin{cases} \frac{1}{r}, & r<r_s \\ \frac{1}{r} \{ {(\frac{r - r_s}{ r_c - r_s})}^3 (-6 {(\frac{r - r_s}{ r_c - r_s})}^2 +15 \frac{r - r_s}{ r_c - r_s} -10) +1 \}, & r_s \leq r<r_c \\ 0, & r \geq r_c \end{cases}\end{split}\]Note that the environment matrix is normalized by davg and dstd.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64. The coordinates of atoms.
type – A Tensor of type int32. The types of atoms.
natoms – A Tensor of type int32. 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.
box – A Tensor. Must have the same type as coord. The box of frames.
mesh – A Tensor of type int32. Gor historical reasons, only the length of the Tensor matters. If size of mesh == 6, pbc is assumed. If size of mesh == 0, no-pbc is assumed.
davg – A Tensor. Must have the same type as coord. Average value of the environment matrix for normalization.
dstd – A Tensor. Must have the same type as coord. Standard deviation of the environment matrix for normalization.
rcut_a – A float. This argument is not used.
rcut_r – A float. The cutoff radius for the environment matrix.
rcut_r_smth – A float. From where the environment matrix should be smoothed.
sel_a – A list of ints. sel_a[i] specifies the maxmum number of type i atoms in the cut-off radius.
sel_r – A list of ints. This argument is not used.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. The environment matrix. descrpt_deriv: A Tensor. Has the same type as coord. The derivative of the environment matrix. rij: A Tensor. Has the same type as coord. The distance between the atoms. nlist: A Tensor of type int32. The neighbor list of each atom.
- deepmd.env.op_module.ProdEnvMatAMix(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
Compute the environment matrix mixing the atom types.
The sorting of neighbor atoms depends not on atom types, but on the distance and index. The atoms in nlist matrix will gather forward and thus save space for gaps of types in ProdEnvMatA, resulting in optimized and relative small sel_a.
The additional outputs are listed as following:
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist, ntype, nmask).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32. ntype: A Tensor of type int32. The corresponding atom types in nlist. nmask: A Tensor of type bool. The atom mask in nlist.
- deepmd.env.op_module.ProdEnvMatANvnmdQuantize(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.ProdEnvMatR(coord, type, natoms, box, mesh, davg, dstd, rcut, rcut_smth, sel, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut – A float.
rcut_smth – A float.
sel – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.ProdForce(net_deriv, in_deriv, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdForceNorot(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdForceSeA(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdForceSeR(net_deriv, in_deriv, nlist, natoms, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdVirial(net_deriv, in_deriv, rij, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdVirialNorot(net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdVirialSeA(net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.ProdVirialSeR(net_deriv, in_deriv, rij, nlist, natoms, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.QuantizeNvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.SoftMinForce(du, sw_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
du – A Tensor. Must be one of the following types: float32, float64.
sw_deriv – A Tensor. Must have the same type as du.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as du.
- deepmd.env.op_module.SoftMinSwitch(type, rij, nlist, natoms, sel_a, sel_r, alpha, rmin, rmax, name=None)
TODO: add doc.
- Parameters
type – A Tensor of type int32.
rij – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
sel_a – A list of ints.
sel_r – A list of ints.
alpha – A float.
rmin – A float.
rmax – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (sw_value, sw_deriv).
sw_value: A Tensor. Has the same type as rij. sw_deriv: A Tensor. Has the same type as rij.
- deepmd.env.op_module.SoftMinVirial(du, sw_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
du – A Tensor. Must be one of the following types: float32, float64.
sw_deriv – A Tensor. Must have the same type as du.
rij – A Tensor. Must have the same type as du.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as du. atom_virial: A Tensor. Has the same type as du.
- deepmd.env.op_module.TabulateFusion(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionGrad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionGradGrad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeA(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeAGrad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeAGradGrad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeR(table, table_info, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeRGrad(table, table_info, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeRGradGrad(table, table_info, em, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeT(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeTGrad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.TabulateFusionSeTGradGrad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.Tanh2Nvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.Tanh4Nvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.UnaggregatedDy2Dx(z, w, dy_dx, dy2_dx, ybar, functype, name=None)
TODO: add doc.
- Parameters
z – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as z.
dy_dx – A Tensor. Must have the same type as z.
dy2_dx – A Tensor. Must have the same type as z.
ybar – A Tensor. Must have the same type as z.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as z.
- deepmd.env.op_module.UnaggregatedDy2DxS(y, dy, w, xbar, functype, name=None)
TODO: add doc.
- Parameters
y – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as y.
w – A Tensor. Must have the same type as y.
xbar – A Tensor. Must have the same type as y.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as y.
- deepmd.env.op_module.UnaggregatedDyDx(z, w, dy_dx, ybar, functype, name=None)
TODO: add doc.
- Parameters
z – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as z.
dy_dx – A Tensor. Must have the same type as z.
ybar – A Tensor. Must have the same type as z.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as z.
- deepmd.env.op_module.UnaggregatedDyDxS(y, w, xbar, functype, name=None)
TODO: add doc.
- Parameters
y – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as y.
xbar – A Tensor. Must have the same type as y.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as y.
- deepmd.env.op_module.descrpt(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, sel_a, sel_r, axis_rule, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
sel_a – A list of ints.
sel_r – A list of ints.
axis_rule – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist, axis, rot_mat).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32. axis: A Tensor of type int32. rot_mat: A Tensor. Has the same type as coord.
- deepmd.env.op_module.descrpt_norot(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.descrpt_se_a(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.descrpt_se_a_ef(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.descrpt_se_a_ef_para(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.descrpt_se_a_ef_vert(coord, type, natoms, box, mesh, ef, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
ef – A Tensor. Must have the same type as coord.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.descrpt_se_r(coord, type, natoms, box, mesh, davg, dstd, rcut, rcut_smth, sel, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut – A float.
rcut_smth – A float.
sel – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.ewald_recp(coord, charge, natoms, box, ewald_beta, ewald_h, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
charge – A Tensor. Must have the same type as coord.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
ewald_beta – A float.
ewald_h – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (energy, force, virial).
energy: A Tensor. Has the same type as coord. force: A Tensor. Has the same type as coord. virial: A Tensor. Has the same type as coord.
- deepmd.env.op_module.gelu(x, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.gelu_custom(x, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.gelu_grad(dy, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.gelu_grad_custom(dy, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.gelu_grad_grad(dy, dy_, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as dy.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.gelu_grad_grad_custom(dy, dy_, x, name=None)
TODO: add doc.
- Parameters
dy – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as dy.
x – A Tensor. Must have the same type as dy.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as dy.
- deepmd.env.op_module.map_aparam(aparam, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
aparam – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as aparam.
- deepmd.env.op_module.map_nvnmd(x, v, dv, grad_v, grad_dv, prec, nbit, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
v – A Tensor. Must have the same type as x.
dv – A Tensor. Must have the same type as x.
grad_v – A Tensor. Must have the same type as x.
grad_dv – A Tensor. Must have the same type as x.
prec – A float.
nbit – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.matmul_nvnmd(x, w, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as x.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.neighbor_stat(coord, type, natoms, box, mesh, rcut, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
rcut – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (max_nbor_size, min_nbor_dist).
max_nbor_size: A Tensor of type int32. min_nbor_dist: A Tensor. Has the same type as coord.
- deepmd.env.op_module.pair_tab(table_info, table_data, type, rij, nlist, natoms, scale, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
table_info – A Tensor of type float64.
table_data – A Tensor of type float64.
type – A Tensor of type int32.
rij – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
scale – A Tensor. Must have the same type as rij.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (atom_energy, force, atom_virial).
atom_energy: A Tensor. Has the same type as rij. force: A Tensor. Has the same type as rij. atom_virial: A Tensor. Has the same type as rij.
- deepmd.env.op_module.parallel_prod_force_se_a(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, parallel=False, start_frac=0, end_frac=1, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
parallel – An optional bool. Defaults to False.
start_frac – An optional float. Defaults to 0.
end_frac – An optional float. Defaults to 1.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_env_mat_a(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
Compute the environment matrix for descriptor se_e2_a.
Each row of the environment matrix \(\mathcal{R}^i\) can be constructed as follows
\[(\mathcal{R}^i)_j = [ \begin{array}{c} s(r_{ji}) & \frac{s(r_{ji})x_{ji}}{r_{ji}} & \frac{s(r_{ji})y_{ji}}{r_{ji}} & \frac{s(r_{ji})z_{ji}}{r_{ji}} \end{array} ]\]In the above equation, \(\mathbf{R}_{ji}=\mathbf{R}_j-\mathbf{R}_i = (x_{ji}, y_{ji}, z_{ji})\) is the relative coordinate and \(r_{ji}=\lVert \mathbf{R}_{ji} \lVert\) is its norm. The switching function \(s(r)\) is defined as:
\[\begin{split}s(r)= \begin{cases} \frac{1}{r}, & r<r_s \\ \frac{1}{r} \{ {(\frac{r - r_s}{ r_c - r_s})}^3 (-6 {(\frac{r - r_s}{ r_c - r_s})}^2 +15 \frac{r - r_s}{ r_c - r_s} -10) +1 \}, & r_s \leq r<r_c \\ 0, & r \geq r_c \end{cases}\end{split}\]Note that the environment matrix is normalized by davg and dstd.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64. The coordinates of atoms.
type – A Tensor of type int32. The types of atoms.
natoms – A Tensor of type int32. 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.
box – A Tensor. Must have the same type as coord. The box of frames.
mesh – A Tensor of type int32. Gor historical reasons, only the length of the Tensor matters. If size of mesh == 6, pbc is assumed. If size of mesh == 0, no-pbc is assumed.
davg – A Tensor. Must have the same type as coord. Average value of the environment matrix for normalization.
dstd – A Tensor. Must have the same type as coord. Standard deviation of the environment matrix for normalization.
rcut_a – A float. This argument is not used.
rcut_r – A float. The cutoff radius for the environment matrix.
rcut_r_smth – A float. From where the environment matrix should be smoothed.
sel_a – A list of ints. sel_a[i] specifies the maxmum number of type i atoms in the cut-off radius.
sel_r – A list of ints. This argument is not used.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. The environment matrix. descrpt_deriv: A Tensor. Has the same type as coord. The derivative of the environment matrix. rij: A Tensor. Has the same type as coord. The distance between the atoms. nlist: A Tensor of type int32. The neighbor list of each atom.
- deepmd.env.op_module.prod_env_mat_a_mix(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
Compute the environment matrix mixing the atom types.
The sorting of neighbor atoms depends not on atom types, but on the distance and index. The atoms in nlist matrix will gather forward and thus save space for gaps of types in ProdEnvMatA, resulting in optimized and relative small sel_a.
The additional outputs are listed as following:
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist, ntype, nmask).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32. ntype: A Tensor of type int32. The corresponding atom types in nlist. nmask: A Tensor of type bool. The atom mask in nlist.
- deepmd.env.op_module.prod_env_mat_a_nvnmd_quantize(coord, type, natoms, box, mesh, davg, dstd, rcut_a, rcut_r, rcut_r_smth, sel_a, sel_r, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut_a – A float.
rcut_r – A float.
rcut_r_smth – A float.
sel_a – A list of ints.
sel_r – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.prod_env_mat_r(coord, type, natoms, box, mesh, davg, dstd, rcut, rcut_smth, sel, name=None)
TODO: add doc.
- Parameters
coord – A Tensor. Must be one of the following types: float32, float64.
type – A Tensor of type int32.
natoms – A Tensor of type int32.
box – A Tensor. Must have the same type as coord.
mesh – A Tensor of type int32.
davg – A Tensor. Must have the same type as coord.
dstd – A Tensor. Must have the same type as coord.
rcut – A float.
rcut_smth – A float.
sel – A list of ints.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (descrpt, descrpt_deriv, rij, nlist).
descrpt: A Tensor. Has the same type as coord. descrpt_deriv: A Tensor. Has the same type as coord. rij: A Tensor. Has the same type as coord. nlist: A Tensor of type int32.
- deepmd.env.op_module.prod_force(net_deriv, in_deriv, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_force_norot(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_force_se_a(net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_force_se_r(net_deriv, in_deriv, nlist, natoms, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_virial(net_deriv, in_deriv, rij, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_virial_norot(net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_virial_se_a(net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.prod_virial_se_r(net_deriv, in_deriv, rij, nlist, natoms, name=None)
TODO: add doc.
- Parameters
net_deriv – A Tensor. Must be one of the following types: float32, float64.
in_deriv – A Tensor. Must have the same type as net_deriv.
rij – A Tensor. Must have the same type as net_deriv.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as net_deriv. atom_virial: A Tensor. Has the same type as net_deriv.
- deepmd.env.op_module.quantize_nvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.soft_min_force(du, sw_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
du – A Tensor. Must be one of the following types: float32, float64.
sw_deriv – A Tensor. Must have the same type as du.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as du.
- deepmd.env.op_module.soft_min_switch(type, rij, nlist, natoms, sel_a, sel_r, alpha, rmin, rmax, name=None)
TODO: add doc.
- Parameters
type – A Tensor of type int32.
rij – A Tensor. Must be one of the following types: float32, float64.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
sel_a – A list of ints.
sel_r – A list of ints.
alpha – A float.
rmin – A float.
rmax – A float.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (sw_value, sw_deriv).
sw_value: A Tensor. Has the same type as rij. sw_deriv: A Tensor. Has the same type as rij.
- deepmd.env.op_module.soft_min_virial(du, sw_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
du – A Tensor. Must be one of the following types: float32, float64.
sw_deriv – A Tensor. Must have the same type as du.
rij – A Tensor. Must have the same type as du.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (virial, atom_virial).
virial: A Tensor. Has the same type as du. atom_virial: A Tensor. Has the same type as du.
- deepmd.env.op_module.tabulate_fusion(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_grad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_grad_grad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_a(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_a_grad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_a_grad_grad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_r(table, table_info, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_r_grad(table, table_info, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_r_grad_grad(table, table_info, em, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_t(table, table_info, em_x, em, last_layer_size, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
last_layer_size – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_t_grad(table, table_info, em_x, em, dy, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dy – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A tuple of Tensor objects (dy_dem_x, dy_dem).
dy_dem_x: A Tensor. Has the same type as table. dy_dem: A Tensor. Has the same type as table.
- deepmd.env.op_module.tabulate_fusion_se_t_grad_grad(table, table_info, em_x, em, dz_dy_dem_x, dz_dy_dem, descriptor, name=None)
TODO: add doc.
- Parameters
table – A Tensor. Must be one of the following types: float32, float64.
table_info – A Tensor. Must have the same type as table.
em_x – A Tensor. Must have the same type as table.
em – A Tensor. Must have the same type as table.
dz_dy_dem_x – A Tensor. Must have the same type as table.
dz_dy_dem – A Tensor. Must have the same type as table.
descriptor – A Tensor. Must have the same type as table.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as table.
- deepmd.env.op_module.tanh2_nvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.tanh4_nvnmd(x, isround, nbit1, nbit2, nbit3, name=None)
TODO: add doc.
- Parameters
x – A Tensor. Must be one of the following types: float32, float64.
isround – An int.
nbit1 – An int.
nbit2 – An int.
nbit3 – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as x.
- deepmd.env.op_module.unaggregated_dy2_dx(z, w, dy_dx, dy2_dx, ybar, functype, name=None)
TODO: add doc.
- Parameters
z – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as z.
dy_dx – A Tensor. Must have the same type as z.
dy2_dx – A Tensor. Must have the same type as z.
ybar – A Tensor. Must have the same type as z.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as z.
- deepmd.env.op_module.unaggregated_dy2_dx_s(y, dy, w, xbar, functype, name=None)
TODO: add doc.
- Parameters
y – A Tensor. Must be one of the following types: float32, float64.
dy – A Tensor. Must have the same type as y.
w – A Tensor. Must have the same type as y.
xbar – A Tensor. Must have the same type as y.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as y.
- deepmd.env.op_module.unaggregated_dy_dx(z, w, dy_dx, ybar, functype, name=None)
TODO: add doc.
- Parameters
z – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as z.
dy_dx – A Tensor. Must have the same type as z.
ybar – A Tensor. Must have the same type as z.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as z.
- deepmd.env.op_module.unaggregated_dy_dx_s(y, w, xbar, functype, name=None)
TODO: add doc.
- Parameters
y – A Tensor. Must be one of the following types: float32, float64.
w – A Tensor. Must have the same type as y.
xbar – A Tensor. Must have the same type as y.
functype – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as y.
op_grads_module
Python wrappers around TensorFlow ops.
This file is MACHINE GENERATED! Do not edit.
- deepmd.env.op_grads_module.ProdForceGrad(grad, net_deriv, in_deriv, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.ProdForceSeAGrad(grad, net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.ProdForceSeRGrad(grad, net_deriv, in_deriv, nlist, natoms, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.ProdVirialGrad(grad, net_deriv, in_deriv, rij, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.ProdVirialSeAGrad(grad, net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.ProdVirialSeRGrad(grad, net_deriv, in_deriv, rij, nlist, natoms, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.SoftMinForceGrad(grad, du, sw_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
du – A Tensor. Must have the same type as grad.
sw_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.SoftMinVirialGrad(grad, du, sw_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
du – A Tensor. Must have the same type as grad.
sw_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_force_grad(grad, net_deriv, in_deriv, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_force_se_a_grad(grad, net_deriv, in_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_force_se_r_grad(grad, net_deriv, in_deriv, nlist, natoms, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_virial_grad(grad, net_deriv, in_deriv, rij, nlist, axis, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
axis – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_virial_se_a_grad(grad, net_deriv, in_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.prod_virial_se_r_grad(grad, net_deriv, in_deriv, rij, nlist, natoms, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
net_deriv – A Tensor. Must have the same type as grad.
in_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.soft_min_force_grad(grad, du, sw_deriv, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
du – A Tensor. Must have the same type as grad.
sw_deriv – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
- deepmd.env.op_grads_module.soft_min_virial_grad(grad, du, sw_deriv, rij, nlist, natoms, n_a_sel, n_r_sel, name=None)
TODO: add doc.
- Parameters
grad – A Tensor. Must be one of the following types: float32, float64.
du – A Tensor. Must have the same type as grad.
sw_deriv – A Tensor. Must have the same type as grad.
rij – A Tensor. Must have the same type as grad.
nlist – A Tensor of type int32.
natoms – A Tensor of type int32.
n_a_sel – An int.
n_r_sel – An int.
name – A name for the operation (optional).
- Returns
A Tensor. Has the same type as grad.
C++ API
Class Hierarchy
File Hierarchy
Full API
Namespaces
Namespace tensorflow
Classes and Structs
Struct deepmd_exception
Defined in File common.h
Inheritance Relationships
public deepmd::tf_exception(Struct tf_exception)
Struct Documentation
- struct deepmd_exception
Subclassed by deepmd::tf_exception
Struct NeighborListData
Defined in File common.h
Struct Documentation
- struct NeighborListData
Public Functions
- void copy_from_nlist(const InputNlist &inlist)
- void shuffle(const std::vector<int> &fwd_map)
- void shuffle_exclude_empty(const std::vector<int> &fwd_map)
- void make_inlist(InputNlist &inlist)
Public Members
- std::vector<int> ilist
Array stores the core region atom’s index.
- std::vector<std::vector<int>> jlist
Array stores the core region atom’s neighbor index.
- std::vector<int> numneigh
Array stores the number of neighbors of core region atoms.
- std::vector<int*> firstneigh
Array stores the the location of the first neighbor of core region atoms.
- void copy_from_nlist(const InputNlist &inlist)
Struct tf_exception
Defined in File common.h
Inheritance Relationships
public deepmd_exception(Struct deepmd_exception)
Struct Documentation
- struct tf_exception : public deepmd_exception
Throw exception if TensorFlow doesn’t work.
Class AtomMap
Defined in File AtomMap.h
Class Documentation
- class AtomMap
Public Functions
- AtomMap()
- AtomMap(const std::vector<int>::const_iterator in_begin, const std::vector<int>::const_iterator in_end)
- template<typename VALUETYPE>
void forward(typename std::vector<VALUETYPE>::iterator out, const typename std::vector<VALUETYPE>::const_iterator in, const int stride = 1) const
- template<typename VALUETYPE>
void backward(typename std::vector<VALUETYPE>::iterator out, const typename std::vector<VALUETYPE>::const_iterator in, const int stride = 1) const
- inline const std::vector<int> &get_type() const
- inline const std::vector<int> &get_fwd_map() const
- inline const std::vector<int> &get_bkw_map() const
- AtomMap()
Class DeepPot
Defined in File DeepPot.h
Class Documentation
- class DeepPot
Deep Potential.
Public Functions
- DeepPot()
DP constructor without initialization.
- ~DeepPot()
- DeepPot(const std::string &model, const int &gpu_rank = 0, const std::string &file_content = "")
DP constructor with initialization.
- Parameters
model – [in] The name of the frozen model file.
gpu_rank – [in] The GPU rank. Default is 0.
file_content – [in] The content of the model file. If it is not empty, DP will read from the string instead of the file.
- void init(const std::string &model, const int &gpu_rank = 0, const std::string &file_content = "")
Initialize the DP.
- Parameters
model – [in] The name of the frozen model file.
gpu_rank – [in] The GPU rank. Default is 0.
file_content – [in] The content of the model file. If it is not empty, DP will read from the string instead of the file.
- void print_summary(const std::string &pre) const
Print the DP summary to the screen.
- Parameters
pre – [in] The prefix to each line.
- template<typename VALUETYPE>
void compute(ENERGYTYPE &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force and virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- template<typename VALUETYPE>
void compute(ENERGYTYPE &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &inlist, const int &ago, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force and virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
nghost – [in] The number of ghost atoms.
inlist – [in] The input neighbour list.
ago – [in] Update the internal neighbour list if ago is 0.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- template<typename VALUETYPE>
void compute(ENERGYTYPE &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_energy, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force, virial, atomic energy, and atomic virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
atom_energy – [out] The atomic energy.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- template<typename VALUETYPE>
void compute(ENERGYTYPE &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_energy, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force, virial, atomic energy, and atomic virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
atom_energy – [out] The atomic energy.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
nghost – [in] The number of ghost atoms.
lmp_list – [in] The input neighbour list.
ago – [in] Update the internal neighbour list if ago is 0.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline int dim_fparam() const
Get the dimension of the frame parameter.
- Returns
The dimension of the frame parameter.
- inline int dim_aparam() const
Get the dimension of the atomic parameter.
- Returns
The dimension of the atomic parameter.
- void get_type_map(std::string &type_map)
Get the type map (element name of the atom types) of this model.
- Parameters
type_map – [out] The type map of this model.
- DeepPot()
Class DeepPotModelDevi
Defined in File DeepPot.h
Class Documentation
- class DeepPotModelDevi
Public Functions
- DeepPotModelDevi()
DP model deviation constructor without initialization.
- ~DeepPotModelDevi()
- DeepPotModelDevi(const std::vector<std::string> &models, const int &gpu_rank = 0, const std::vector<std::string> &file_contents = std::vector<std::string>())
DP model deviation constructor with initialization.
- Parameters
models – [in] The names of the frozen model files.
gpu_rank – [in] The GPU rank. Default is 0.
file_contents – [in] The contents of the model files. If it is not empty, DP will read from the strings instead of the files.
- void init(const std::vector<std::string> &models, const int &gpu_rank = 0, const std::vector<std::string> &file_contents = std::vector<std::string>())
Initialize the DP model deviation contrcutor.
- Parameters
models – [in] The names of the frozen model files.
gpu_rank – [in] The GPU rank. Default is 0.
file_contents – [in] The contents of the model files. If it is not empty, DP will read from the strings instead of the files.
- template<typename VALUETYPE>
void compute(std::vector<ENERGYTYPE> &all_ener, std::vector<std::vector<VALUETYPE>> &all_force, std::vector<std::vector<VALUETYPE>> &all_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force and virial by using these DP models.
- Parameters
all_ener – [out] The system energies of all models.
all_force – [out] The forces on each atom of all models.
all_virial – [out] The virials of all models.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
nghost – [in] The number of ghost atoms.
lmp_list – [in] The input neighbour list.
ago – [in] Update the internal neighbour list if ago is 0.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- template<typename VALUETYPE>
void compute(std::vector<ENERGYTYPE> &all_ener, std::vector<std::vector<VALUETYPE>> &all_force, std::vector<std::vector<VALUETYPE>> &all_virial, std::vector<std::vector<VALUETYPE>> &all_atom_energy, std::vector<std::vector<VALUETYPE>> &all_atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago, const std::vector<VALUETYPE> &fparam = std::vector<VALUETYPE>(), const std::vector<VALUETYPE> &aparam = std::vector<VALUETYPE>()) Evaluate the energy, force, virial, atomic energy, and atomic virial by using these DP models.
- Parameters
all_ener – [out] The system energies of all models.
all_force – [out] The forces on each atom of all models.
all_virial – [out] The virials of all models.
all_atom_energy – [out] The atomic energies of all models.
all_atom_virial – [out] The atomic virials of all models.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9.
nghost – [in] The number of ghost atoms.
lmp_list – [in] The input neighbour list.
ago – [in] Update the internal neighbour list if ago is 0.
fparam – [in] The frame parameter. The array can be of size : nframes x dim_fparam. dim_fparam. Then all frames are assumed to be provided with the same fparam.
aparam – [in] The atomic parameter The array can be of size : nframes x natoms x dim_aparam. natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. dim_aparam. Then all frames and atoms are provided with the same aparam.
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline int dim_fparam() const
Get the dimension of the frame parameter.
- Returns
The dimension of the frame parameter.
- inline int dim_aparam() const
Get the dimension of the atomic parameter.
- Returns
The dimension of the atomic parameter.
- template<typename VALUETYPE>
void compute_avg(VALUETYPE &dener, const std::vector<VALUETYPE> &all_energy) Compute the average energy.
- Parameters
dener – [out] The average energy.
all_energy – [in] The energies of all models.
- template<typename VALUETYPE>
void compute_avg(std::vector<VALUETYPE> &avg, const std::vector<std::vector<VALUETYPE>> &xx) Compute the average of vectors.
- Parameters
avg – [out] The average of vectors.
xx – [in] The vectors of all models.
- template<typename VALUETYPE>
void compute_std(std::vector<VALUETYPE> &std, const std::vector<VALUETYPE> &avg, const std::vector<std::vector<VALUETYPE>> &xx, const int &stride) Compute the standard deviation of vectors.
- Parameters
std – [out] The standard deviation of vectors.
avg – [in] The average of vectors.
xx – [in] The vectors of all models.
stride – [in] The stride to compute the deviation.
- template<typename VALUETYPE>
void compute_relative_std(std::vector<VALUETYPE> &std, const std::vector<VALUETYPE> &avg, const VALUETYPE eps, const int &stride) Compute the relative standard deviation of vectors.
- Parameters
std – [out] The standard deviation of vectors.
avg – [in] The average of vectors.
eps – [in] The level parameter for computing the deviation.
stride – [in] The stride to compute the deviation.
- template<typename VALUETYPE>
void compute_std_e(std::vector<VALUETYPE> &std, const std::vector<VALUETYPE> &avg, const std::vector<std::vector<VALUETYPE>> &xx) Compute the standard deviation of atomic energies.
- Parameters
std – [out] The standard deviation of atomic energies.
avg – [in] The average of atomic energies.
xx – [in] The vectors of all atomic energies.
- template<typename VALUETYPE>
void compute_std_f(std::vector<VALUETYPE> &std, const std::vector<VALUETYPE> &avg, const std::vector<std::vector<VALUETYPE>> &xx) Compute the standard deviation of forces.
- Parameters
std – [out] The standard deviation of forces.
avg – [in] The average of forces.
xx – [in] The vectors of all forces.
- template<typename VALUETYPE>
void compute_relative_std_f(std::vector<VALUETYPE> &std, const std::vector<VALUETYPE> &avg, const VALUETYPE eps) Compute the relative standard deviation of forces.
- Parameters
std – [out] The relative standard deviation of forces.
avg – [in] The relative average of forces.
eps – [in] The level parameter for computing the deviation.
- DeepPotModelDevi()
Class DeepTensor
Defined in File DeepTensor.h
Class Documentation
- class DeepTensor
Deep Tensor.
Public Functions
- DeepTensor()
Deep Tensor constructor without initialization.
- ~DeepTensor()
- DeepTensor(const std::string &model, const int &gpu_rank = 0, const std::string &name_scope = "")
Deep Tensor constructor with initialization..
- Parameters
model – [in] The name of the frozen model file.
gpu_rank – [in] The GPU rank. Default is 0.
name_scope – [in] Name scopes of operations.
- void init(const std::string &model, const int &gpu_rank = 0, const std::string &name_scope = "")
Initialize the Deep Tensor.
- Parameters
model – [in] The name of the frozen model file.
gpu_rank – [in] The GPU rank. Default is 0.
name_scope – [in] Name scopes of operations.
- void print_summary(const std::string &pre) const
Print the DP summary to the screen.
- Parameters
pre – [in] The prefix to each line.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &value, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the value by using this model.
- Parameters
value – [out] The value to evalute, usually would be the atomic tensor.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &value, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &inlist) Evaluate the value by using this model.
- Parameters
value – [out] The value to evalute, usually would be the atomic tensor.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
nghost – [in] The number of ghost atoms.
inlist – [in] The input neighbour list.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the global tensor and component-wise force and virial.
- Parameters
global_tensor – [out] The global tensor to evalute.
force – [out] The component-wise force of the global tensor, size odim x natoms x 3.
virial – [out] The component-wise virial of the global tensor, size odim x 9.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &inlist) Evaluate the global tensor and component-wise force and virial.
- Parameters
global_tensor – [out] The global tensor to evalute.
force – [out] The component-wise force of the global tensor, size odim x natoms x 3.
virial – [out] The component-wise virial of the global tensor, size odim x 9.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
nghost – [in] The number of ghost atoms.
inlist – [in] The input neighbour list.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_tensor, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the global tensor and component-wise force and virial.
- Parameters
global_tensor – [out] The global tensor to evalute.
force – [out] The component-wise force of the global tensor, size odim x natoms x 3.
virial – [out] The component-wise virial of the global tensor, size odim x 9.
atom_tensor – [out] The atomic tensor value of the model, size natoms x odim.
atom_virial – [out] The component-wise atomic virial of the global tensor, size odim x natoms x 9.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_tensor, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &inlist) Evaluate the global tensor and component-wise force and virial.
- Parameters
global_tensor – [out] The global tensor to evalute.
force – [out] The component-wise force of the global tensor, size odim x natoms x 3.
virial – [out] The component-wise virial of the global tensor, size odim x 9.
atom_tensor – [out] The atomic tensor value of the model, size natoms x odim.
atom_virial – [out] The component-wise atomic virial of the global tensor, size odim x natoms x 9.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9.
nghost – [in] The number of ghost atoms.
inlist – [in] The input neighbour list.
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline int output_dim() const
Get the output dimension.
- Returns
The output dimension.
- inline const std::vector<int> &sel_types() const
- DeepTensor()
Class DipoleChargeModifier
Defined in File DataModifier.h
Class Documentation
- class DipoleChargeModifier
Public Functions
- DipoleChargeModifier()
- DipoleChargeModifier(const std::string &model, const int &gpu_rank = 0, const std::string &name_scope = "")
- ~DipoleChargeModifier()
- void init(const std::string &model, const int &gpu_rank = 0, const std::string &name_scope = "")
- void print_summary(const std::string &pre) const
- template<typename VALUETYPE>
void compute(std::vector<VALUETYPE> &dfcorr_, std::vector<VALUETYPE> &dvcorr_, const std::vector<VALUETYPE> &dcoord_, const std::vector<int> &datype_, const std::vector<VALUETYPE> &dbox, const std::vector<std::pair<int, int>> &pairs, const std::vector<VALUETYPE> &delef_, const int nghost, const InputNlist &lmp_list)
- inline double cutoff() const
- inline int numb_types() const
- inline std::vector<int> sel_types() const
- DipoleChargeModifier()
Functions
Function deepmd::check_status
Defined in File common.h
Function Documentation
- void deepmd::check_status(const tensorflow::Status &status)
Check TensorFlow status. Exit if not OK.
- Parameters
status – [in] TensorFlow status.
Function deepmd::convert_pbtxt_to_pb
Defined in File common.h
Function Documentation
- void deepmd::convert_pbtxt_to_pb(std::string fn_pb_txt, std::string fn_pb)
Convert pbtxt to pb.
- Parameters
fn_pb_txt – [in] Filename of the pb txt file.
fn_pb – [in] Filename of the pb file.
Function deepmd::get_env_nthreads
Defined in File common.h
Function Documentation
- void deepmd::get_env_nthreads(int &num_intra_nthreads, int &num_inter_nthreads)
Get the number of threads from the environment variable.
A warning will be thrown if environmental variables are not set.
- Parameters
num_intra_nthreads – [out] The number of intra threads. Read from TF_INTRA_OP_PARALLELISM_THREADS.
num_inter_nthreads – [out] The number of inter threads. Read from TF_INTER_OP_PARALLELISM_THREADS.
Function deepmd::load_op_library
Defined in File common.h
Function Documentation
- void deepmd::load_op_library()
Dynamically load OP library. This should be called before loading graphs.
Function deepmd::model_compatable
Defined in File common.h
Function Documentation
- bool deepmd::model_compatable(std::string &model_version)
Check if the model version is supported.
- Parameters
model_version – [in] The model version.
- Returns
Whether the model is supported (true or false).
Function deepmd::name_prefix
Defined in File common.h
Function Documentation
- std::string deepmd::name_prefix(const std::string &name_scope)
Function deepmd::read_file_to_string
Defined in File common.h
Function Documentation
- void deepmd::read_file_to_string(std::string model, std::string &file_content)
Read model file to a string.
- Parameters
model – [in] Path to the model.
file_content – [out] Content of the model file.
Template Function deepmd::select_by_type
Defined in File common.h
Function Documentation
Template Function deepmd::select_map(std::vector<VT>&, const std::vector<VT>&, const std::vector<int>&, const int&)
Defined in File common.h
Function Documentation
Template Function deepmd::select_map(typename std::vector<VT>::iterator, const typename std::vector<VT>::const_iterator, const std::vector<int>&, const int&)
Defined in File common.h
Function Documentation
Template Function deepmd::select_map_inv(std::vector<VT>&, const std::vector<VT>&, const std::vector<int>&, const int&)
Defined in File common.h
Function Documentation
Template Function deepmd::select_map_inv(typename std::vector<VT>::iterator, const typename std::vector<VT>::const_iterator, const std::vector<int>&, const int&)
Defined in File common.h
Function Documentation
Template Function deepmd::select_real_atoms
Defined in File common.h
Function Documentation
Function deepmd::session_get_dtype
Defined in File common.h
Function Documentation
- int deepmd::session_get_dtype(tensorflow::Session *session, const std::string name, const std::string scope = "")
Get the type of a tensor.
- Parameters
session – [in] TensorFlow session.
name – [in] The name of the tensor.
scope – [in] The scope of the tensor.
- Returns
The type of the tensor as int.
Template Function deepmd::session_get_scalar
Defined in File common.h
Function Documentation
- template<typename VT>
VT deepmd::session_get_scalar(tensorflow::Session *session, const std::string name, const std::string scope = "") Get the value of a tensor.
- Parameters
session – [in] TensorFlow session.
name – [in] The name of the tensor.
scope – [in] The scope of the tensor.
- Returns
The value of the tensor.
Template Function deepmd::session_get_vector
Defined in File common.h
Function Documentation
- template<typename VT>
void deepmd::session_get_vector(std::vector<VT> &o_vec, tensorflow::Session *session, const std::string name_, const std::string scope = "") Get the vector of a tensor.
- Parameters
o_vec – [out] The output vector.
session – [in] TensorFlow session.
name – [in] The name of the tensor.
scope – [in] The scope of the tensor.
Template Function deepmd::session_input_tensors(std::vector<std::pair<std::string, tensorflow::Tensor>>&, const std::vector<VALUETYPE>&, const int&, const std::vector<int>&, const std::vector<VALUETYPE>&, const double&, const std::vector<VALUETYPE>&, const std::vector<VALUETYPE>&, const deepmd::AtomMap&, const std::string)
Defined in File common.h
Function Documentation
- template<typename MODELTYPE, typename VALUETYPE>
int deepmd::session_input_tensors(std::vector<std::pair<std::string, tensorflow::Tensor>> &input_tensors, const std::vector<VALUETYPE> &dcoord_, const int &ntypes, const std::vector<int> &datype_, const std::vector<VALUETYPE> &dbox, const double &cell_size, const std::vector<VALUETYPE> &fparam_, const std::vector<VALUETYPE> &aparam_, const deepmd::AtomMap &atommap, const std::string scope = "") Get input tensors.
- Parameters
input_tensors – [out] Input tensors.
dcoord_ – [in] Coordinates of atoms.
ntypes – [in] Number of atom types.
datype_ – [in] Atom types.
dbox – [in] Box matrix.
cell_size – [in] Cell size.
fparam_ – [in] Frame parameters.
aparam_ – [in] Atom parameters.
atommap – [in] Atom map.
scope – [in] The scope of the tensors.
Template Function deepmd::session_input_tensors(std::vector<std::pair<std::string, tensorflow::Tensor>>&, const std::vector<VALUETYPE>&, const int&, const std::vector<int>&, const std::vector<VALUETYPE>&, InputNlist&, const std::vector<VALUETYPE>&, const std::vector<VALUETYPE>&, const deepmd::AtomMap&, const int, const int, const std::string)
Defined in File common.h
Function Documentation
- template<typename MODELTYPE, typename VALUETYPE>
int deepmd::session_input_tensors(std::vector<std::pair<std::string, tensorflow::Tensor>> &input_tensors, const std::vector<VALUETYPE> &dcoord_, const int &ntypes, const std::vector<int> &datype_, const std::vector<VALUETYPE> &dbox, InputNlist &dlist, const std::vector<VALUETYPE> &fparam_, const std::vector<VALUETYPE> &aparam_, const deepmd::AtomMap &atommap, const int nghost, const int ago, const std::string scope = "") Get input tensors.
- Parameters
input_tensors – [out] Input tensors.
dcoord_ – [in] Coordinates of atoms.
ntypes – [in] Number of atom types.
datype_ – [in] Atom types.
dlist – [in] Neighbor list.
fparam_ – [in] Frame parameters.
aparam_ – [in] Atom parameters.
atommap – [in] Atom map.
nghost – [in] Number of ghost atoms.
ago – [in] Update the internal neighbour list if ago is 0.
scope – [in] The scope of the tensors.
Typedefs
Typedef deepmd::ENERGYTYPE
Defined in File common.h
Typedef Documentation
- typedef double deepmd::ENERGYTYPE
Typedef deepmd::STRINGTYPE
Defined in File tf_private.h
Typedef Documentation
- typedef std::string deepmd::STRINGTYPE
C API
Class Hierarchy
File Hierarchy
Full API
Namespaces
Classes and Structs
Struct InputNlist
Defined in File deepmd.hpp
Struct Documentation
Struct DP_DeepPot
Defined in File c_api_internal.h
Struct Documentation
- struct DP_DeepPot
Struct DP_DeepPotModelDevi
Defined in File c_api_internal.h
Struct Documentation
- struct DP_DeepPotModelDevi
Public Functions
- DP_DeepPotModelDevi(deepmd::DeepPotModelDevi &dp)
Public Members
- deepmd::DeepPotModelDevi dp
- DP_DeepPotModelDevi(deepmd::DeepPotModelDevi &dp)
Struct DP_DeepTensor
Defined in File c_api_internal.h
Struct Documentation
- struct DP_DeepTensor
Public Functions
- DP_DeepTensor(deepmd::DeepTensor &dt)
Public Members
- deepmd::DeepTensor dt
- DP_DeepTensor(deepmd::DeepTensor &dt)
Struct DP_Nlist
Defined in File c_api_internal.h
Struct Documentation
- struct DP_Nlist
Public Functions
- DP_Nlist(deepmd::InputNlist &nl)
Public Members
- deepmd::InputNlist nl
- DP_Nlist(deepmd::InputNlist &nl)
Class DeepPot
Defined in File deepmd.hpp
Class Documentation
- class DeepPot
Deep Potential.
Public Functions
- inline DeepPot()
DP constructor without initialization.
- inline ~DeepPot()
- inline DeepPot(const std::string &model)
DP constructor with initialization.
- Parameters
model – [in] The name of the frozen model file.
- inline void init(const std::string &model)
Initialize the DP.
- Parameters
model – [in] The name of the frozen model file.
- template<typename VALUETYPE>
inline void compute(double &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the energy, force and virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(double &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_energy, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the energy, force, virial, atomic energy, and atomic virial by using this DP.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
atom_energy – [out] The atomic energy.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(double &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago) Evaluate the energy, force and virial by using this DP with the neighbor list.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
- template<typename VALUETYPE>
inline void compute(double &ener, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_energy, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago) Evaluate the energy, force, virial, atomic energy, and atomic virial by using this DP with the neighbor list.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
atom_energy – [out] The atomic energy.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline void get_type_map(std::string &type_map)
Get the type map (element name of the atom types) of this model.
- Parameters
type_map – [out] The type map of this model.
- inline DeepPot()
Class DeepPotModelDevi
Defined in File deepmd.hpp
Class Documentation
- class DeepPotModelDevi
Deep Potential model deviation.
Public Functions
- inline DeepPotModelDevi()
DP model deviation constructor without initialization.
- inline ~DeepPotModelDevi()
- inline DeepPotModelDevi(const std::vector<std::string> &models)
DP model deviation constructor with initialization.
- Parameters
models – [in] The names of the frozen model file.
- inline void init(const std::vector<std::string> &models)
Initialize the DP model deviation.
- Parameters
model – [in] The name of the frozen model file.
- template<typename VALUETYPE>
inline void compute(std::vector<double> &ener, std::vector<std::vector<VALUETYPE>> &force, std::vector<std::vector<VALUETYPE>> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago) Evaluate the energy, force and virial by using this DP model deviation.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(std::vector<double> &ener, std::vector<std::vector<VALUETYPE>> &force, std::vector<std::vector<VALUETYPE>> &virial, std::vector<std::vector<VALUETYPE>> &atom_energy, std::vector<std::vector<VALUETYPE>> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list, const int &ago) Evaluate the energy, force, virial, atomic energy, and atomic virial by using this DP model deviation.
- Parameters
ener – [out] The system energy.
force – [out] The force on each atom.
virial – [out] The virial.
atom_energy – [out] The atomic energy.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline DeepPotModelDevi()
Class DeepTensor
Defined in File deepmd.hpp
Class Documentation
- class DeepTensor
Deep Tensor.
Public Functions
- inline DeepTensor()
Deep Tensor constructor without initialization.
- inline ~DeepTensor()
- inline DeepTensor(const std::string &model)
DeepTensor constructor with initialization.
- Parameters
model – [in] The name of the frozen model file.
- inline void init(const std::string &model)
Initialize the DeepTensor.
- Parameters
model – [in] The name of the frozen model file.
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &tensor, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the tensor, force and virial by using this Deep Tensor.
- Parameters
tensor – [out] The atomic tensor.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &tensor, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list) Evaluate the tensor, force and virial by using this Deep Tensor with the neighbor list.
- Parameters
tensor – [out] The tensor.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the global tensor, force and virial by using this Deep Tensor.
- Parameters
global_tensor – [out] The global tensor.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_tensor, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box) Evaluate the global tensor, force, virial, atomic tensor, and atomic virial by using this Deep Tensor.
- Parameters
global_tensor – [out] The global tensor.
force – [out] The force on each atom.
virial – [out] The virial.
atom_tensor – [out] The atomic tensor.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list) Evaluate the global tensor, force and virial by using this Deep Tensor with the neighbor list.
- Parameters
global_tensor – [out] The global tensor.
force – [out] The force on each atom.
virial – [out] The virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
- template<typename VALUETYPE>
inline void compute(std::vector<VALUETYPE> &global_tensor, std::vector<VALUETYPE> &force, std::vector<VALUETYPE> &virial, std::vector<VALUETYPE> &atom_tensor, std::vector<VALUETYPE> &atom_virial, const std::vector<VALUETYPE> &coord, const std::vector<int> &atype, const std::vector<VALUETYPE> &box, const int nghost, const InputNlist &lmp_list) Evaluate the global tensor, force, virial, atomic tensor, and atomic virial by using this Deep Tensor with the neighbor list.
- Parameters
global_tensor – [out] The global tensor.
force – [out] The force on each atom.
virial – [out] The virial.
atom_tensor – [out] The atomic tensor.
atom_virial – [out] The atomic virial.
coord – [in] The coordinates of atoms. The array should be of size nframes x natoms x 3.
atype – [in] The atom types. The list should contain natoms ints.
box – [in] The cell of the region. The array should be of size nframes x 9 (PBC) or empty (no PBC).
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
- inline double cutoff() const
Get the cutoff radius.
- Returns
The cutoff radius.
- inline int numb_types() const
Get the number of types.
- Returns
The number of types.
- inline int output_dim() const
Get the output dimension.
- Returns
The output dimension.
- inline std::vector<int> sel_types() const
- inline DeepTensor()
Functions
Template Function _DP_DeepPotCompute
Defined in File deepmd.hpp
Function Documentation
Specialized Template Function _DP_DeepPotCompute< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotCompute<double>(DP_DeepPot *dp, const int natom, const double *coord, const int *atype, const double *cell, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Specialized Template Function _DP_DeepPotCompute< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotCompute<float>(DP_DeepPot *dp, const int natom, const float *coord, const int *atype, const float *cell, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Template Function _DP_DeepPotComputeNList
Defined in File deepmd.hpp
Function Documentation
- template<typename FPTYPE>
inline void _DP_DeepPotComputeNList(DP_DeepPot *dp, const int natom, const FPTYPE *coord, const int *atype, const FPTYPE *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, FPTYPE *force, FPTYPE *virial, FPTYPE *atomic_energy, FPTYPE *atomic_virial)
Specialized Template Function _DP_DeepPotComputeNList< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotComputeNList<double>(DP_DeepPot *dp, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Specialized Template Function _DP_DeepPotComputeNList< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotComputeNList<float>(DP_DeepPot *dp, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Template Function _DP_DeepPotModelDeviComputeNList
Defined in File deepmd.hpp
Function Documentation
- template<typename FPTYPE>
inline void _DP_DeepPotModelDeviComputeNList(DP_DeepPotModelDevi *dp, const int natom, const FPTYPE *coord, const int *atype, const FPTYPE *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, FPTYPE *force, FPTYPE *virial, FPTYPE *atomic_energy, FPTYPE *atomic_virial)
Specialized Template Function _DP_DeepPotModelDeviComputeNList< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotModelDeviComputeNList<double>(DP_DeepPotModelDevi *dp, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Specialized Template Function _DP_DeepPotModelDeviComputeNList< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepPotModelDeviComputeNList<float>(DP_DeepPotModelDevi *dp, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Template Function _DP_DeepTensorCompute
Defined in File deepmd.hpp
Function Documentation
Specialized Template Function _DP_DeepTensorCompute< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorCompute<double>(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, double *global_tensor, double *force, double *virial, double **atomic_tensor, double *atomic_virial, int *size_at)
Specialized Template Function _DP_DeepTensorCompute< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorCompute<float>(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, float *global_tensor, float *force, float *virial, float **atomic_tensor, float *atomic_virial, int *size_at)
Template Function _DP_DeepTensorComputeNList
Defined in File deepmd.hpp
Function Documentation
- template<typename FPTYPE>
inline void _DP_DeepTensorComputeNList(DP_DeepTensor *dt, const int natom, const FPTYPE *coord, const int *atype, const FPTYPE *cell, const int nghost, const DP_Nlist *nlist, FPTYPE *global_tensor, FPTYPE *force, FPTYPE *virial, FPTYPE **atomic_energy, FPTYPE *atomic_virial, int *size_at)
Specialized Template Function _DP_DeepTensorComputeNList< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeNList<double>(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, double *global_tensor, double *force, double *virial, double **atomic_tensor, double *atomic_virial, int *size_at)
Specialized Template Function _DP_DeepTensorComputeNList< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeNList<float>(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, float *global_tensor, float *force, float *virial, float **atomic_tensor, float *atomic_virial, int *size_at)
Template Function _DP_DeepTensorComputeTensor
Defined in File deepmd.hpp
Function Documentation
- template<typename FPTYPE>
inline void _DP_DeepTensorComputeTensor(DP_DeepTensor *dt, const int natom, const FPTYPE *coord, const int *atype, const FPTYPE *cell, FPTYPE **tensor, int *size)
Specialized Template Function _DP_DeepTensorComputeTensor< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeTensor<double>(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, double **tensor, int *size)
Specialized Template Function _DP_DeepTensorComputeTensor< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeTensor<float>(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, float **tensor, int *size)
Template Function _DP_DeepTensorComputeTensorNList
Defined in File deepmd.hpp
Function Documentation
Specialized Template Function _DP_DeepTensorComputeTensorNList< double >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeTensorNList<double>(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, double **tensor, int *size)
Specialized Template Function _DP_DeepTensorComputeTensorNList< float >
Defined in File deepmd.hpp
Function Documentation
- template<>
inline void _DP_DeepTensorComputeTensorNList<float>(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, float **tensor, int *size)
Function deepmd::hpp::convert_nlist
Defined in File deepmd.hpp
Function Documentation
- inline void deepmd::hpp::convert_nlist(InputNlist &to_nlist, std::vector<std::vector<int>> &from_nlist)
Convert int vector to InputNlist.
- Parameters
to_nlist – [out] InputNlist.
from_nlist – [in] 2D int vector. The first axis represents the centeral atoms and the second axis represents the neighbor atoms.
Function deepmd::hpp::convert_pbtxt_to_pb
Defined in File deepmd.hpp
Function Documentation
- inline void deepmd::hpp::convert_pbtxt_to_pb(std::string fn_pb_txt, std::string fn_pb)
Convert pbtxt to pb.
- Parameters
fn_pb_txt – [in] Filename of the pb txt file.
fn_pb – [in] Filename of the pb file.
Function DP_ConvertPbtxtToPb
Defined in File c_api.h
Function Documentation
- void DP_ConvertPbtxtToPb(const char *c_pbtxt, const char *c_pb)
Convert PBtxt to PB.
- Parameters
c_pbtxt – [in] The name of the PBtxt file.
c_pb – [in] The name of the PB file.
Function DP_DeepPotCompute
Defined in File c_api.h
Function Documentation
- void DP_DeepPotCompute(DP_DeepPot *dp, const int natom, const double *coord, const int *atype, const double *cell, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Evaluate the energy, force and virial by using a DP. (double version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotComputef
Defined in File c_api.h
Function Documentation
- void DP_DeepPotComputef(DP_DeepPot *dp, const int natom, const float *coord, const int *atype, const float *cell, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Evaluate the energy, force and virial by using a DP. (float version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotComputeNList
Defined in File c_api.h
Function Documentation
- void DP_DeepPotComputeNList(DP_DeepPot *dp, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Evaluate the energy, force and virial by using a DP with the neighbor list. (double version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotComputeNListf
Defined in File c_api.h
Function Documentation
- void DP_DeepPotComputeNListf(DP_DeepPot *dp, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Evaluate the energy, force and virial by using a DP with the neighbor list. (float version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotGetCutoff
Defined in File c_api.h
Function Documentation
- double DP_DeepPotGetCutoff(DP_DeepPot *dp)
Get the type map of a DP.
- Parameters
dp – [in] The DP to use.
- Returns
The cutoff radius.
Function DP_DeepPotGetNumbTypes
Defined in File c_api.h
Function Documentation
- int DP_DeepPotGetNumbTypes(DP_DeepPot *dp)
Get the type map of a DP.
- Parameters
dp – [in] The DP to use.
- Returns
The number of types of the DP.
Function DP_DeepPotGetTypeMap
Defined in File c_api.h
Function Documentation
- const char *DP_DeepPotGetTypeMap(DP_DeepPot *dp)
Get the type map of a DP.
- Parameters
dp – [in] The DP to use.
- Returns
The type map of the DP.
Function DP_DeepPotModelDeviComputeNList
Defined in File c_api.h
Function Documentation
- void DP_DeepPotModelDeviComputeNList(DP_DeepPotModelDevi *dp, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, double *force, double *virial, double *atomic_energy, double *atomic_virial)
Evaluate the energy, force and virial by using a DP model deviation with neighbor list. (double version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP model deviation to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotModelDeviComputeNListf
Defined in File c_api.h
Function Documentation
- void DP_DeepPotModelDeviComputeNListf(DP_DeepPotModelDevi *dp, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, const int ago, double *energy, float *force, float *virial, float *atomic_energy, float *atomic_virial)
Evaluate the energy, force and virial by using a DP model deviation with neighbor list. (float version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dp – [in] The DP model deviation to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
ago – [in] Update the internal neighbour list if ago is 0.
energy – [out] Output energy.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_energy – [out] Output atomic energy. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
Function DP_DeepPotModelDeviGetCutoff
Defined in File c_api.h
Function Documentation
- double DP_DeepPotModelDeviGetCutoff(DP_DeepPotModelDevi *dp)
Get the type map of a DP model deviation.
- Parameters
dp – [in] The DP model deviation to use.
- Returns
The cutoff radius.
Function DP_DeepPotModelDeviGetNumbTypes
Defined in File c_api.h
Function Documentation
- int DP_DeepPotModelDeviGetNumbTypes(DP_DeepPotModelDevi *dp)
Get the type map of a DP model deviation.
- Parameters
dp – [in] The DP model deviation to use.
- Returns
The number of types of the DP model deviation.
Function DP_DeepTensorCompute
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorCompute(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, double *global_tensor, double *force, double *virial, double **atomic_tensor, double *atomic_virial, int *size_at)
Evaluate the global tensor, force and virial by using a DP. (double version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
global_tensor – [out] Output global tensor.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_tensor – [out] Output atomic tensor. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
size_at – [out] Output size of atomic tensor.
Function DP_DeepTensorComputef
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputef(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, float *global_tensor, float *force, float *virial, float **atomic_tensor, float *atomic_virial, int *size_at)
Evaluate the global tensor, force and virial by using a DP. (float version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
global_tensor – [out] Output global tensor.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_tensor – [out] Output atomic tensor. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
size_at – [out] Output size of atomic tensor.
Function DP_DeepTensorComputeNList
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeNList(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, double *global_tensor, double *force, double *virial, double **atomic_tensor, double *atomic_virial, int *size_at)
Evaluate the global tensor, force and virial by using a DP with the neighbor list. (double version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
global_tensor – [out] Output global tensor.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_tensor – [out] Output atomic tensor. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
size_at – [out] Output size of atomic tensor.
Function DP_DeepTensorComputeNListf
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeNListf(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, float *global_tensor, float *force, float *virial, float **atomic_tensor, float *atomic_virial, int *size_at)
Evaluate the global tensor, force and virial by using a DP with the neighbor list. (float version)
Warning
The output arrays should be allocated before calling this function. Pass NULL if not required.
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
global_tensor – [out] Output global tensor.
force – [out] Output force. The array should be of size natoms x 3.
virial – [out] Output virial. The array should be of size 9.
atomic_tensor – [out] Output atomic tensor. The array should be of size natoms.
atomic_virial – [out] Output atomic virial. The array should be of size natoms x 9.
size_at – [out] Output size of atomic tensor.
Function DP_DeepTensorComputeTensor
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeTensor(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, double **tensor, int *size)
Evaluate the tensor by using a DP. (double version)
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
tensor – [out] Output tensor.
Function DP_DeepTensorComputeTensorf
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeTensorf(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, float **tensor, int *size)
Evaluate the tensor by using a DP. (float version)
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
tensor – [out] Output tensor.
size – [out] Output size of the tensor.
Function DP_DeepTensorComputeTensorNList
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeTensorNList(DP_DeepTensor *dt, const int natom, const double *coord, const int *atype, const double *cell, const int nghost, const DP_Nlist *nlist, double **tensor, int *size)
Evaluate the tensor by using a DP with the neighbor list. (double version)
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
tensor – [out] Output tensor.
size – [out] Output size of the tensor.
Function DP_DeepTensorComputeTensorNListf
Defined in File c_api.h
Function Documentation
- void DP_DeepTensorComputeTensorNListf(DP_DeepTensor *dt, const int natom, const float *coord, const int *atype, const float *cell, const int nghost, const DP_Nlist *nlist, float **tensor, int *size)
Evaluate the tensor by using a DP with the neighbor list. (float version)
- Parameters
dt – [in] The Deep Tensor to use.
natoms – [in] The number of atoms.
coord – [in] The coordinates of atoms. The array should be of size natoms x 3.
atype – [in] The atom types. The array should contain natoms ints.
box – [in] The cell of the region. The array should be of size 9. Pass NULL if pbc is not used.
nghost – [in] The number of ghost atoms.
nlist – [in] The neighbor list.
tensor – [out] Output tensor.
size – [out] Output size of the tensor.
Function DP_DeepTensorGetCutoff
Defined in File c_api.h
Function Documentation
- double DP_DeepTensorGetCutoff(DP_DeepTensor *dt)
Get the type map of a Deep Tensor.
- Parameters
dt – [in] The Deep Tensor to use.
- Returns
The cutoff radius.
Function DP_DeepTensorGetNumbSelTypes
Defined in File c_api.h
Function Documentation
- int DP_DeepTensorGetNumbSelTypes(DP_DeepTensor *dt)
Get the number of sel types of a Deep Tensor.
- Parameters
dt – [in] The Deep Tensor to use.
- Returns
The number of sel types
Function DP_DeepTensorGetNumbTypes
Defined in File c_api.h
Function Documentation
- int DP_DeepTensorGetNumbTypes(DP_DeepTensor *dt)
Get the type map of a Deep Tensor.
- Parameters
dt – [in] The Deep Tensor to use.
- Returns
The number of types of the Deep Tensor.
Function DP_DeepTensorGetOutputDim
Defined in File c_api.h
Function Documentation
- int DP_DeepTensorGetOutputDim(DP_DeepTensor *dt)
Get the output dimension of a Deep Tensor.
- Parameters
dt – [in] The Deep Tensor to use.
- Returns
The output dimension of the Deep Tensor.
Function DP_DeepTensorGetSelTypes
Defined in File c_api.h
Function Documentation
- int *DP_DeepTensorGetSelTypes(DP_DeepTensor *dt)
Get sel types of a Deep Tensor.
- Parameters
dt – [in] The Deep Tensor to use.
- Returns
The sel types
Function DP_NewDeepPot
Defined in File c_api.h
Function Documentation
- DP_DeepPot *DP_NewDeepPot(const char *c_model)
DP constructor with initialization.
- Parameters
c_model – [in] The name of the frozen model file.
- Returns
A pointer to the deep potential.
Function DP_NewDeepPotModelDevi
Defined in File c_api.h
Function Documentation
- DP_DeepPotModelDevi *DP_NewDeepPotModelDevi(const char **c_models, int n_models)
DP model deviation constructor with initialization.
- Parameters
c_models – [in] The array of the name of the frozen model file.
nmodels – [in] The number of models.
Function DP_NewDeepTensor
Defined in File c_api.h
Function Documentation
- DP_DeepTensor *DP_NewDeepTensor(const char *c_model)
Deep Tensor constructor with initialization.
- Parameters
c_model – [in] The name of the frozen model file.
- Returns
A pointer to the deep tensor.
Function DP_NewNlist
Defined in File c_api.h
Function Documentation
- DP_Nlist *DP_NewNlist(int inum_, int *ilist_, int *numneigh_, int **firstneigh_)
Create a new neighbor list.
- Parameters
inum_ – [in] Number of core region atoms
Array – [in] stores the core region atom’s index
Array – [in] stores the core region atom’s neighbor atom number
Array – [in] stores the core region atom’s neighbor index
- Returns
A pointer to the neighbor list.
Typedefs
Typedef DP_DeepPot
Defined in File c_api.h
Typedef Documentation
- typedef struct DP_DeepPot DP_DeepPot
The deep potential.
Typedef DP_DeepPotModelDevi
Defined in File c_api.h
Typedef Documentation
- typedef struct DP_DeepPotModelDevi DP_DeepPotModelDevi
The deep potential model deviation.
Typedef DP_DeepTensor
Defined in File c_api.h
Typedef Documentation
- typedef struct DP_DeepTensor DP_DeepTensor
The deep tensor.
Typedef DP_Nlist
Defined in File c_api.h
Typedef Documentation
- typedef struct DP_Nlist DP_Nlist
Neighbor list.
Core API
Class Hierarchy
File Hierarchy
Full API
Namespaces
Namespace deepmd
Classes
Functions
Function deepmd::cos_switch(const double&, const double&, const double&)
Function deepmd::cos_switch(double&, double&, const double&, const double&, const double&)
Template Function deepmd::malloc_device_memory(FPTYPE *&, const std::vector<FPTYPE>&)
Template Function deepmd::malloc_device_memory(FPTYPE *&, const int)
Template Function deepmd::malloc_device_memory(FPTYPE *&, std::vector<FPTYPE>&)
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, const std::vector<FPTYPE>&)
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, const FPTYPE *, const int)
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, std::vector<FPTYPE>&)
Template Function deepmd::memcpy_device_to_host(const FPTYPE *, std::vector<FPTYPE>&)
Template Function deepmd::memcpy_device_to_host(const FPTYPE *, FPTYPE *, const int)
Template Function deepmd::memcpy_device_to_host(FPTYPE *, std::vector<FPTYPE>&)
Template Function deepmd::memcpy_host_to_device(FPTYPE *, const std::vector<FPTYPE>&)
Template Function deepmd::memcpy_host_to_device(FPTYPE *, const FPTYPE *, const int)
Template Function deepmd::memcpy_host_to_device(FPTYPE *, std::vector<FPTYPE>&)
Template Function deepmd::tabulate_fusion_se_a_grad_gpu_cuda
Template Function deepmd::tabulate_fusion_se_a_grad_grad_cpu
Template Function deepmd::tabulate_fusion_se_a_grad_grad_gpu_cuda
Template Function deepmd::tabulate_fusion_se_r_grad_gpu_cuda
Template Function deepmd::tabulate_fusion_se_r_grad_grad_cpu
Template Function deepmd::tabulate_fusion_se_r_grad_grad_gpu_cuda
Template Function deepmd::tabulate_fusion_se_t_grad_gpu_cuda
Template Function deepmd::tabulate_fusion_se_t_grad_grad_cpu
Template Function deepmd::tabulate_fusion_se_t_grad_grad_gpu_cuda
Template Function deepmd::test_encoding_decoding_nbor_info_gpu_cuda
Variables
Namespace std
Classes and Structs
Struct deepmd_exception
Defined in File errors.h
Inheritance Relationships
public std::runtime_error
public deepmd::deepmd_exception_oom(Struct deepmd_exception_oom)
Struct Documentation
- struct deepmd_exception : public std::runtime_error
General DeePMD-kit exception. Throw if anything doesn’t work.
Subclassed by deepmd::deepmd_exception_oom
Struct deepmd_exception_oom
Defined in File errors.h
Inheritance Relationships
public deepmd::deepmd_exception(Struct deepmd_exception)
Struct Documentation
- struct deepmd_exception_oom : public deepmd::deepmd_exception
Template Struct EwaldParameters
Defined in File ewald.h
Struct Documentation
- template<typename VALUETYPE>
struct EwaldParameters
Struct InputNlist
Defined in File neighbor_list.h
Struct Documentation
- struct InputNlist
Construct InputNlist with the input LAMMPS nbor list info.
Template Struct Region
Defined in File region.h
Struct Documentation
- template<typename FPTYPE>
struct Region
Template Struct DescrptSeRGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct DescrptSeRGPUExecuteFunctor Public Functions
- void operator()(const FPTYPE *coord, const int *type, const int *ilist, const int *jrange, const int *jlist, int *array_int, unsigned long long *array_longlong, const FPTYPE *avg, const FPTYPE *std, FPTYPE *descript, FPTYPE *descript_deriv, FPTYPE *rij, int *nlist, const int nloc, const int nall, const int nnei, const int ndescrpt, const float rcut_r, const float rcut_r_smth, const std::vector<int> sec_a, const bool fill_nei_a, const int MAGIC_NUMBER)
- void operator()(const FPTYPE *coord, const int *type, const int *ilist, const int *jrange, const int *jlist, int *array_int, unsigned long long *array_longlong, const FPTYPE *avg, const FPTYPE *std, FPTYPE *descript, FPTYPE *descript_deriv, FPTYPE *rij, int *nlist, const int nloc, const int nall, const int nnei, const int ndescrpt, const float rcut_r, const float rcut_r_smth, const std::vector<int> sec_a, const bool fill_nei_a, const int MAGIC_NUMBER)
Template Struct GeluGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct GeluGPUExecuteFunctor
Template Struct GeluGradGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct GeluGradGPUExecuteFunctor
Template Struct GeluGradGradGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct GeluGradGradGPUExecuteFunctor
Template Struct ProdForceSeAGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct ProdForceSeAGPUExecuteFunctor
Template Struct ProdForceSeRGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct ProdForceSeRGPUExecuteFunctor
Template Struct ProdVirialSeAGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct ProdVirialSeAGPUExecuteFunctor
Template Struct ProdVirialSeRGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct ProdVirialSeRGPUExecuteFunctor
Template Struct TabulateCheckerGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct TabulateCheckerGPUExecuteFunctor
Template Struct TabulateFusionGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct TabulateFusionGPUExecuteFunctor
Template Struct TabulateFusionGradGPUExecuteFunctor
Defined in File DeviceFunctor.h
Struct Documentation
- template<typename FPTYPE>
struct TabulateFusionGradGPUExecuteFunctor
Template Class SimulationRegion
Defined in File SimulationRegion.h
Class Documentation
- template<typename VALUETYPE>
class SimulationRegion Public Functions
- inline void reinitBox(const double *boxv)
- inline void affineTransform(const double *affine_map)
- inline void reinitOrigin(const double *orig)
- inline void reinitOrigin(const std::vector<double> &orig)
- void backup()
- void recover()
- SimulationRegion()
- ~SimulationRegion()
- inline double *getBoxTensor()
- inline const double *getBoxTensor() const
- inline double *getRecBoxTensor()
- inline const double *getRecBoxTensor() const
- inline double *getBoxOrigin()
- inline const double *getBoxOrigin() const
- inline double getVolume() const
- inline void toFaceDistance(double *dd) const
- inline bool isPeriodic(const int dim) const
- inline double *getShiftVec(const int index = 0)
- inline const double *getShiftVec(const int index = 0) const
- inline int getShiftIndex(const int *idx) const
- inline int getNullShiftIndex() const
- inline virtual void diffNearestNeighbor(const VALUETYPE x0, const VALUETYPE y0, const VALUETYPE z0, const VALUETYPE x1, const VALUETYPE y1, const VALUETYPE z1, VALUETYPE &dx, VALUETYPE &dy, VALUETYPE &dz) const
Public Static Functions
- static inline int compactIndex(const int *idx)
- static inline int getNumbShiftVec()
- static inline int getShiftVecTotalSize()
Protected Functions
- void computeShiftVec()
- inline double *getInterShiftVec(const int index = 0)
- inline const double *getInterShiftVec(const int index = 0) const
Protected Static Functions
- static inline int index3to1(const int tx, const int ty, const int tz)
- inline void reinitBox(const double *boxv)
Functions
Function build_nlist(std::vector<std::vector<int>>&, std::vector<std::vector<int>>&, const std::vector<double>&, const int&, const double&, const double&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const SimulationRegion<double>&, const std::vector<int>&)
Defined in File neighbor_list.h
Function Documentation
- void build_nlist(std::vector<std::vector<int>> &nlist0, std::vector<std::vector<int>> &nlist1, const std::vector<double> &coord, const int &nloc, const double &rc0, const double &rc1, const std::vector<int> &nat_stt_, const std::vector<int> &nat_end_, const std::vector<int> &ext_stt_, const std::vector<int> &ext_end_, const SimulationRegion<double> ®ion, const std::vector<int> &global_grid)
Function build_nlist(std::vector<std::vector<int>>&, std::vector<std::vector<int>>&, const std::vector<double>&, const double&, const double&, const std::vector<int>&, const SimulationRegion<double>&)
Defined in File neighbor_list.h
Function Documentation
- void build_nlist(std::vector<std::vector<int>> &nlist0, std::vector<std::vector<int>> &nlist1, const std::vector<double> &coord, const double &rc0, const double &rc1, const std::vector<int> &grid, const SimulationRegion<double> ®ion)
Function build_nlist(std::vector<std::vector<int>>&, std::vector<std::vector<int>>&, const std::vector<double>&, const std::vector<int>&, const std::vector<int>&, const double&, const double&, const std::vector<int>&, const SimulationRegion<double>&)
Defined in File neighbor_list.h
Function Documentation
- void build_nlist(std::vector<std::vector<int>> &nlist0, std::vector<std::vector<int>> &nlist1, const std::vector<double> &coord, const std::vector<int> &sel0, const std::vector<int> &sel1, const double &rc0, const double &rc1, const std::vector<int> &grid, const SimulationRegion<double> ®ion)
Function build_nlist(std::vector<std::vector<int>>&, std::vector<std::vector<int>>&, const std::vector<double>&, const double&, const double&, const SimulationRegion<double> *)
Defined in File neighbor_list.h
Function Documentation
- void build_nlist(std::vector<std::vector<int>> &nlist0, std::vector<std::vector<int>> &nlist1, const std::vector<double> &coord, const double &rc0_, const double &rc1_, const SimulationRegion<double> *region = NULL)
Function compute_descriptor(std::vector<double>&, std::vector<double>&, std::vector<double>&, const std::vector<double>&, const int&, const std::vector<int>&, const SimulationRegion<double>&, const bool&, const int&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const int, const int, const int, const int)
Defined in File ComputeDescriptor.h
Function Documentation
- inline void compute_descriptor(std::vector<double> &descrpt_a, std::vector<double> &descrpt_r, std::vector<double> &rot_mat, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &fmt_nlist_r, const std::vector<int> &sec_a, const std::vector<int> &sec_r, const int axis0_type, const int axis0_idx, const int axis1_type, const int axis1_idx)
Function compute_descriptor(std::vector<double>&, std::vector<double>&, std::vector<double>&, std::vector<double>&, std::vector<double>&, std::vector<double>&, std::vector<double>&, const std::vector<double>&, const int&, const std::vector<int>&, const SimulationRegion<double>&, const bool&, const int&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const std::vector<int>&, const int, const int, const int, const int)
Defined in File ComputeDescriptor.h
Function Documentation
- inline void compute_descriptor(std::vector<double> &descrpt_a, std::vector<double> &descrpt_a_deriv, std::vector<double> &descrpt_r, std::vector<double> &descrpt_r_deriv, std::vector<double> &rij_a, std::vector<double> &rij_r, std::vector<double> &rot_mat, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &fmt_nlist_r, const std::vector<int> &sec_a, const std::vector<int> &sec_r, const int axis0_type, const int axis0_idx, const int axis1_type, const int axis1_idx)
Function compute_descriptor_se_a_ef_para
Defined in File ComputeDescriptor.h
Function Documentation
- inline void compute_descriptor_se_a_ef_para(std::vector<double> &descrpt_a, std::vector<double> &descrpt_a_deriv, std::vector<double> &rij_a, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const std::vector<double> &efield, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &sec_a, const double &rmin, const double &rmax)
Function compute_descriptor_se_a_ef_vert
Defined in File ComputeDescriptor.h
Function Documentation
- inline void compute_descriptor_se_a_ef_vert(std::vector<double> &descrpt_a, std::vector<double> &descrpt_a_deriv, std::vector<double> &rij_a, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const std::vector<double> &efield, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &sec_a, const double &rmin, const double &rmax)
Function compute_descriptor_se_a_extf
Defined in File ComputeDescriptor.h
Function Documentation
- inline void compute_descriptor_se_a_extf(std::vector<double> &descrpt_a, std::vector<double> &descrpt_a_deriv, std::vector<double> &rij_a, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const std::vector<double> &efield, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &sec_a, const double &rmin, const double &rmax)
Function compute_dRdT
Defined in File ComputeDescriptor.h
Function Documentation
Warning
doxygenfunction: Unable to resolve function “compute_dRdT” with arguments (double (*), const double*, const double*, const double*) in doxygen xml output for project “core” from directory: _build/core/xml/. Potential matches:
- void compute_dRdT(double (*dRdT)[9], const double *r1, const double *r2, const double *rot)
Function compute_dRdT_1
Defined in File ComputeDescriptor.h
Function Documentation
Warning
doxygenfunction: Unable to resolve function “compute_dRdT_1” with arguments (double (*), const double*, const double*, const double*) in doxygen xml output for project “core” from directory: _build/core/xml/. Potential matches:
- void compute_dRdT_1(double (*dRdT)[9], const double *r1, const double *r2, const double *rot)
Function compute_dRdT_2
Defined in File ComputeDescriptor.h
Function Documentation
Warning
doxygenfunction: Unable to resolve function “compute_dRdT_2” with arguments (double (*), const double*, const double*, const double*) in doxygen xml output for project “core” from directory: _build/core/xml/. Potential matches:
- void compute_dRdT_2(double (*dRdT)[9], const double *r1, const double *r2, const double *rot)
Function copy_coord
Defined in File neighbor_list.h
Function Documentation
- void copy_coord(std::vector<double> &out_c, std::vector<int> &out_t, std::vector<int> &mapping, std::vector<int> &ncell, std::vector<int> &ngcell, const std::vector<double> &in_c, const std::vector<int> &in_t, const double &rc, const SimulationRegion<double> ®ion)
Template Function deepmd::build_nlist_cpu
Defined in File neighbor_list.h
Function Documentation
- template<typename FPTYPE>
int deepmd::build_nlist_cpu(InputNlist &nlist, int *max_list_size, const FPTYPE *c_cpy, const int &nloc, const int &nall, const int &mem_size, const float &rcut)
Template Function deepmd::build_nlist_gpu
Defined in File neighbor_list.h
Function Documentation
- template<typename FPTYPE>
int deepmd::build_nlist_gpu(InputNlist &nlist, int *max_list_size, int *nlist_data, const FPTYPE *c_cpy, const int &nloc, const int &nall, const int &mem_size, const float &rcut)
Template Function deepmd::compute_cell_info
Defined in File coord.h
Function Documentation
Function deepmd::convert_nlist
Defined in File neighbor_list.h
Function Documentation
- void deepmd::convert_nlist(InputNlist &to_nlist, std::vector<std::vector<int>> &from_nlist)
Construct the InputNlist with a two-dimensional vector.
- Parameters
to_nlist – InputNlist struct which stores the neighbor information of the core region atoms.
from_nlist – Vector which stores the neighbor information of the core region atoms.
Function deepmd::convert_nlist_gpu_device
Defined in File neighbor_list.h
Function Documentation
- void deepmd::convert_nlist_gpu_device(InputNlist &gpu_nlist, InputNlist &cpu_nlist, int *&gpu_memory, const int &max_nbor_size)
Convert the a host memory InputNlist to a device memory InputNlist.
- Parameters
cpu_nlist – Host memory InputNlist struct which stores the neighbor information of the core region atoms
gpu_nlist – Device memory InputNlist struct which stores the neighbor information of the core region atoms
gpu_memory – Device array which stores the elements of gpu_nlist
max_nbor_size –
Template Function deepmd::convert_to_inter_cpu
Defined in File region.h
Function Documentation
Template Function deepmd::convert_to_inter_gpu
Defined in File region.h
Function Documentation
Template Function deepmd::convert_to_phys_cpu
Defined in File region.h
Function Documentation
Template Function deepmd::convert_to_phys_gpu
Defined in File region.h
Function Documentation
Template Function deepmd::copy_coord_cpu
Defined in File coord.h
Function Documentation
Template Function deepmd::copy_coord_gpu
Defined in File coord.h
Function Documentation
- template<typename FPTYPE>
int deepmd::copy_coord_gpu(FPTYPE *out_c, int *out_t, int *mapping, int *nall, int *int_data, const FPTYPE *in_c, const int *in_t, const int &nloc, const int &mem_nall, const int &loc_cellnum, const int &total_cellnum, const int *cell_info, const deepmd::Region<FPTYPE> ®ion)
Function deepmd::cos_switch(const double&, const double&, const double&)
Defined in File switcher.h
Function Documentation
- inline double deepmd::cos_switch(const double &xx, const double &rmin, const double &rmax)
Function deepmd::cos_switch(double&, double&, const double&, const double&, const double&)
Defined in File switcher.h
Function Documentation
- inline void deepmd::cos_switch(double &vv, double &dd, const double &xx, const double &rmin, const double &rmax)
Template Function deepmd::cprod
Defined in File utilities.h
Function Documentation
Function deepmd::cum_sum
Defined in File utilities.h
Function Documentation
- void deepmd::cum_sum(std::vector<int> &sec, const std::vector<int> &n_sel)
Template Function deepmd::delete_device_memory
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::dot1
Defined in File utilities.h
Function Documentation
Template Function deepmd::dot2
Defined in File utilities.h
Function Documentation
Template Function deepmd::dot3
Defined in File utilities.h
Function Documentation
Template Function deepmd::dot4
Defined in File utilities.h
Function Documentation
Template Function deepmd::dotmv3
Defined in File utilities.h
Function Documentation
Function deepmd::DPGetDeviceCount
Defined in File gpu_cuda.h
Function Documentation
- inline void deepmd::DPGetDeviceCount(int &gpu_num)
Function deepmd::DPSetDevice
Defined in File gpu_cuda.h
Function Documentation
- inline cudaError_t deepmd::DPSetDevice(int rank)
Template Function deepmd::env_mat_a_cpu
Defined in File env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::env_mat_a_cpu(std::vector<FPTYPE> &descrpt_a, std::vector<FPTYPE> &descrpt_a_deriv, std::vector<FPTYPE> &rij_a, const std::vector<FPTYPE> &posi, const std::vector<int> &type, const int &i_idx, const std::vector<int> &fmt_nlist, const std::vector<int> &sec, const float &rmin, const float &rmax)
Template Function deepmd::env_mat_a_nvnmd_quantize_cpu
Defined in File env_mat_nvnmd.h
Function Documentation
Warning
doxygenfunction: Unable to resolve function “deepmd::env_mat_a_nvnmd_quantize_cpu” with arguments (std::vector<FPTYPE>&, std::vector<FPTYPE>&, std::vector<FPTYPE>&, const std::vector<FPTYPE>&, const std::vector<int>&, const int&, const std::vector<int>&, const std::vector<int>&, const float&, const float&, const FPTYPE) in doxygen xml output for project “core” from directory: _build/core/xml/. Potential matches:
- template<typename FPTYPE> void env_mat_a_nvnmd_quantize_cpu(std::vector<FPTYPE> &descrpt_a, std::vector<FPTYPE> &descrpt_a_deriv, std::vector<FPTYPE> &rij_a, const std::vector<FPTYPE> &posi, const std::vector<int> &type, const int &i_idx, const std::vector<int> &fmt_nlist, const std::vector<int> &sec, const float &rmin, const float &rmax, const FPTYPE precs[3])
Function deepmd::env_mat_nbor_update
Defined in File prod_env_mat.h
Function Documentation
- void deepmd::env_mat_nbor_update(InputNlist &inlist, InputNlist &gpu_inlist, int &max_nbor_size, int *&nbor_list_dev, const int *mesh, const int size)
Template Function deepmd::env_mat_r_cpu
Defined in File env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::env_mat_r_cpu(std::vector<FPTYPE> &descrpt_a, std::vector<FPTYPE> &descrpt_a_deriv, std::vector<FPTYPE> &rij_a, const std::vector<FPTYPE> &posi, const std::vector<int> &type, const int &i_idx, const std::vector<int> &fmt_nlist_a, const std::vector<int> &sec_a, const float &rmin, const float &rmax)
Template Function deepmd::ewald_recp
Defined in File ewald.h
Function Documentation
Template Function deepmd::format_nbor_list_gpu_cuda
Defined in File fmt_nlist.h
Function Documentation
- template<typename FPTYPE>
void deepmd::format_nbor_list_gpu_cuda(int *nlist, const FPTYPE *coord, const int *type, const deepmd::InputNlist &gpu_inlist, int *array_int, uint_64 *array_longlong, const int max_nbor_size, const int nloc, const int nall, const float rcut, const std::vector<int> sec)
Template Function deepmd::format_nlist_cpu
Defined in File fmt_nlist.h
Function Documentation
- template<typename FPTYPE>
void deepmd::format_nlist_cpu(int *nlist, const InputNlist &in_nlist, const FPTYPE *coord, const int *type, const int nloc, const int nall, const float rcut, const std::vector<int> sec)
Function deepmd::free_nlist_gpu_device
Defined in File neighbor_list.h
Function Documentation
- void deepmd::free_nlist_gpu_device(InputNlist &gpu_nlist)
Reclaim the allocated device memory of struct InputNlist.
- Parameters
gpu_nlist – Device memory InputNlist struct which stores the neighbor information of the core region atoms
Template Function deepmd::gelu_cpu
Defined in File gelu.h
Function Documentation
Template Function deepmd::gelu_gpu_cuda
Defined in File gelu.h
Function Documentation
Template Function deepmd::gelu_grad_cpu
Defined in File gelu.h
Function Documentation
Template Function deepmd::gelu_grad_gpu_cuda
Defined in File gelu.h
Function Documentation
Template Function deepmd::gelu_grad_grad_cpu
Defined in File gelu.h
Function Documentation
Template Function deepmd::gelu_grad_grad_gpu_cuda
Defined in File gelu.h
Function Documentation
Template Function deepmd::init_region_cpu
Defined in File region.h
Function Documentation
Template Function deepmd::invsqrt
Defined in File utilities.h
Function Documentation
Specialized Template Function deepmd::invsqrt< double >
Defined in File utilities.h
Function Documentation
- template<>
inline double deepmd::invsqrt<double>(const double x)
Specialized Template Function deepmd::invsqrt< float >
Defined in File utilities.h
Function Documentation
- template<>
inline float deepmd::invsqrt<float>(const float x)
Template Function deepmd::malloc_device_memory(FPTYPE *&, const std::vector<FPTYPE>&)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::malloc_device_memory(FPTYPE *&, const int)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::malloc_device_memory(FPTYPE *&, std::vector<FPTYPE>&)
Defined in File gpu_rocm.h
Function Documentation
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, const std::vector<FPTYPE>&)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, const FPTYPE *, const int)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::malloc_device_memory_sync(FPTYPE *&, std::vector<FPTYPE>&)
Defined in File gpu_rocm.h
Function Documentation
Template Function deepmd::map_aparam_cpu
Defined in File map_aparam.h
Function Documentation
Function deepmd::max_numneigh
Defined in File neighbor_list.h
Function Documentation
- int deepmd::max_numneigh(const InputNlist &to_nlist)
Compute the max number of neighbors within the core region atoms.
- Parameters
to_nlist – InputNlist struct which stores the neighbor information of the core region atoms.
- Return values
max – number of neighbors
- Returns
integer
Template Function deepmd::memcpy_device_to_host(const FPTYPE *, std::vector<FPTYPE>&)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::memcpy_device_to_host(const FPTYPE *, FPTYPE *, const int)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::memcpy_device_to_host(FPTYPE *, std::vector<FPTYPE>&)
Defined in File gpu_rocm.h
Function Documentation
Template Function deepmd::memcpy_host_to_device(FPTYPE *, const std::vector<FPTYPE>&)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::memcpy_host_to_device(FPTYPE *, const FPTYPE *, const int)
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::memcpy_host_to_device(FPTYPE *, std::vector<FPTYPE>&)
Defined in File gpu_rocm.h
Function Documentation
Template Function deepmd::memset_device_memory
Defined in File gpu_cuda.h
Function Documentation
Template Function deepmd::normalize_coord_cpu
Defined in File coord.h
Function Documentation
Template Function deepmd::normalize_coord_gpu
Defined in File coord.h
Function Documentation
Template Function deepmd::pair_tab_cpu
Defined in File pair_tab.h
Function Documentation
- template<typename FPTYPE>
void deepmd::pair_tab_cpu(FPTYPE *energy, FPTYPE *force, FPTYPE *virial, const double *table_info, const double *table_data, const FPTYPE *rij, const FPTYPE *scale, const int *type, const int *nlist, const int *natoms, const std::vector<int> &sel_a, const std::vector<int> &sel_r)
Template Function deepmd::prod_env_mat_a_cpu
Defined in File prod_env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::prod_env_mat_a_cpu(FPTYPE *em, FPTYPE *em_deriv, FPTYPE *rij, int *nlist, const FPTYPE *coord, const int *type, const InputNlist &inlist, const int max_nbor_size, const FPTYPE *avg, const FPTYPE *std, const int nloc, const int nall, const float rcut, const float rcut_smth, const std::vector<int> sec, const int *f_type = NULL)
Template Function deepmd::prod_env_mat_a_gpu_cuda
Defined in File prod_env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::prod_env_mat_a_gpu_cuda(FPTYPE *em, FPTYPE *em_deriv, FPTYPE *rij, int *nlist, const FPTYPE *coord, const int *type, const InputNlist &gpu_inlist, int *array_int, unsigned long long *array_longlong, const int max_nbor_size, const FPTYPE *avg, const FPTYPE *std, const int nloc, const int nall, const float rcut, const float rcut_smth, const std::vector<int> sec, const int *f_type = NULL)
Template Function deepmd::prod_env_mat_a_nvnmd_quantize_cpu
Defined in File prod_env_mat_nvnmd.h
Function Documentation
Warning
doxygenfunction: Unable to resolve function “deepmd::prod_env_mat_a_nvnmd_quantize_cpu” with arguments (FPTYPE*, FPTYPE*, FPTYPE*, int*, const FPTYPE*, const int*, const InputNlist&, const int, const FPTYPE*, const FPTYPE*, const int, const int, const float, const float, const std::vector<int>, const FPTYPE) in doxygen xml output for project “core” from directory: _build/core/xml/. Potential matches:
- template<typename FPTYPE> void prod_env_mat_a_nvnmd_quantize_cpu(FPTYPE *em, FPTYPE *em_deriv, FPTYPE *rij, int *nlist, const FPTYPE *coord, const int *type, const InputNlist &inlist, const int max_nbor_size, const FPTYPE *avg, const FPTYPE *std, const int nloc, const int nall, const float rcut, const float rcut_smth, const std::vector<int> sec, const FPTYPE precs[3])
Template Function deepmd::prod_env_mat_r_cpu
Defined in File prod_env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::prod_env_mat_r_cpu(FPTYPE *em, FPTYPE *em_deriv, FPTYPE *rij, int *nlist, const FPTYPE *coord, const int *type, const InputNlist &inlist, const int max_nbor_size, const FPTYPE *avg, const FPTYPE *std, const int nloc, const int nall, const float rcut, const float rcut_smth, const std::vector<int> sec)
Template Function deepmd::prod_env_mat_r_gpu_cuda
Defined in File prod_env_mat.h
Function Documentation
- template<typename FPTYPE>
void deepmd::prod_env_mat_r_gpu_cuda(FPTYPE *em, FPTYPE *em_deriv, FPTYPE *rij, int *nlist, const FPTYPE *coord, const int *type, const InputNlist &gpu_inlist, int *array_int, unsigned long long *array_longlong, const int max_nbor_size, const FPTYPE *avg, const FPTYPE *std, const int nloc, const int nall, const float rcut, const float rcut_smth, const std::vector<int> sec)
Template Function deepmd::prod_force_a_cpu
Defined in File prod_force.h
Function Documentation
Template Function deepmd::prod_force_a_gpu_cuda
Defined in File prod_force.h
Function Documentation
Template Function deepmd::prod_force_grad_a_cpu
Defined in File prod_force_grad.h
Function Documentation
Template Function deepmd::prod_force_grad_a_gpu_cuda
Defined in File prod_force_grad.h
Function Documentation
Template Function deepmd::prod_force_grad_r_cpu
Defined in File prod_force_grad.h
Function Documentation
Template Function deepmd::prod_force_grad_r_gpu_cuda
Defined in File prod_force_grad.h
Function Documentation
Template Function deepmd::prod_force_r_cpu
Defined in File prod_force.h
Function Documentation
Template Function deepmd::prod_force_r_gpu_cuda
Defined in File prod_force.h
Function Documentation
Template Function deepmd::prod_virial_a_cpu
Defined in File prod_virial.h
Function Documentation
Template Function deepmd::prod_virial_a_gpu_cuda
Defined in File prod_virial.h
Function Documentation
Template Function deepmd::prod_virial_grad_a_cpu
Defined in File prod_virial_grad.h
Function Documentation
Template Function deepmd::prod_virial_grad_a_gpu_cuda
Defined in File prod_virial_grad.h
Function Documentation
Template Function deepmd::prod_virial_grad_r_cpu
Defined in File prod_virial_grad.h
Function Documentation
Template Function deepmd::prod_virial_grad_r_gpu_cuda
Defined in File prod_virial_grad.h
Function Documentation
Template Function deepmd::prod_virial_r_cpu
Defined in File prod_virial.h
Function Documentation
Template Function deepmd::prod_virial_r_gpu_cuda
Defined in File prod_virial.h
Function Documentation
Template Function deepmd::soft_min_switch_cpu
Defined in File soft_min_switch.h
Function Documentation
Template Function deepmd::soft_min_switch_force_cpu
Defined in File soft_min_switch_force.h
Function Documentation
Template Function deepmd::soft_min_switch_force_grad_cpu
Defined in File soft_min_switch_force_grad.h
Function Documentation
Template Function deepmd::soft_min_switch_virial_cpu
Defined in File soft_min_switch_virial.h
Function Documentation
Template Function deepmd::soft_min_switch_virial_grad_cpu
Defined in File soft_min_switch_virial_grad.h
Function Documentation
Function deepmd::spline3_switch
Defined in File switcher.h
Function Documentation
- inline void deepmd::spline3_switch(double &vv, double &dd, const double &xx, const double &rmin, const double &rmax)
Template Function deepmd::spline5_switch
Defined in File switcher.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_grad_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_grad_grad_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_a_grad_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_grad_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_grad_grad_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_r_grad_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_t_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_t_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_t_grad_cpu
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_t_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
Template Function deepmd::tabulate_fusion_se_t_grad_grad_cpu
Defined in File tabulate.h
Function Documentation
- template<typename FPTYPE>
void deepmd::tabulate_fusion_se_t_grad_grad_cpu(FPTYPE *dz_dy, const FPTYPE *table, const FPTYPE *table_info, const FPTYPE *em_x, const FPTYPE *em, const FPTYPE *dz_dy_dem_x, const FPTYPE *dz_dy_dem, const int nloc, const int nnei_i, const int nnei_j, const int last_layer_size)
Template Function deepmd::tabulate_fusion_se_t_grad_grad_gpu_cuda
Defined in File tabulate.h
Function Documentation
- template<typename FPTYPE>
void deepmd::tabulate_fusion_se_t_grad_grad_gpu_cuda(FPTYPE *dz_dy, const FPTYPE *table, const FPTYPE *table_info, const FPTYPE *em_x, const FPTYPE *em, const FPTYPE *dz_dy_dem_x, const FPTYPE *dz_dy_dem, const int nloc, const int nnei_i, const int nnei_j, const int last_layer_size)
Template Function deepmd::test_encoding_decoding_nbor_info_gpu_cuda
Defined in File fmt_nlist.h
Function Documentation
Function deepmd::use_nei_info_cpu
Defined in File neighbor_list.h
Function Documentation
- void deepmd::use_nei_info_cpu(int *nlist, int *ntype, bool *nmask, const int *type, const int *nlist_map, const int nloc, const int nnei, const int ntypes, const bool b_nlist_map)
Function deepmd::use_nei_info_gpu
Defined in File neighbor_list.h
Function Documentation
- void deepmd::use_nei_info_gpu(int *nlist, int *ntype, bool *nmask, const int *type, const int *nlist_map, const int nloc, const int nnei, const int ntypes, const bool b_nlist_map)
Function deepmd::use_nlist_map
Defined in File neighbor_list.h
Function Documentation
- void deepmd::use_nlist_map(int *nlist, const int *nlist_map, const int nloc, const int nnei)
Template Function deepmd::volume_cpu
Defined in File region.h
Function Documentation
Template Function deepmd::volume_gpu
Defined in File region.h
Function Documentation
Function DPAssert(cudaError_t, const char *, int, bool)
Defined in File gpu_cuda.h
Function Documentation
- inline void DPAssert(cudaError_t code, const char *file, int line, bool abort = true)
Function DPAssert(hipError_t, const char *, int, bool)
Defined in File gpu_rocm.h
Function Documentation
- inline void DPAssert(hipError_t code, const char *file, int line, bool abort = true)
Function env_mat_a
Defined in File env_mat.h
Function Documentation
- void env_mat_a(std::vector<double> &descrpt_a, std::vector<double> &descrpt_a_deriv, std::vector<double> &rij_a, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const int &i_idx, const std::vector<int> &fmt_nlist, const std::vector<int> &sec, const double &rmin, const double &rmax)
Function env_mat_r
Defined in File env_mat.h
Function Documentation
- void env_mat_r(std::vector<double> &descrpt_r, std::vector<double> &descrpt_r_deriv, std::vector<double> &rij_r, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const int &i_idx, const std::vector<int> &fmt_nlist, const std::vector<int> &sec, const double &rmin, const double &rmax)
Template Function format_nlist_i_cpu
Defined in File fmt_nlist.h
Function Documentation
Function format_nlist_i_fill_a
Defined in File fmt_nlist.h
Function Documentation
- int format_nlist_i_fill_a(std::vector<int> &fmt_nei_idx_a, std::vector<int> &fmt_nei_idx_r, const std::vector<double> &posi, const int &ntypes, const std::vector<int> &type, const SimulationRegion<double> ®ion, const bool &b_pbc, const int &i_idx, const std::vector<int> &nei_idx_a, const std::vector<int> &nei_idx_r, const double &rcut, const std::vector<int> &sec_a, const std::vector<int> &sec_r)
Function nborAssert(cudaError_t, const char *, int, bool)
Defined in File gpu_cuda.h
Function Documentation
- inline void nborAssert(cudaError_t code, const char *file, int line, bool abort = true)
Function nborAssert(hipError_t, const char *, int, bool)
Defined in File gpu_rocm.h
Function Documentation
- inline void nborAssert(hipError_t code, const char *file, int line, bool abort = true)
Function omp_get_num_threads
Defined in File ewald.h
Function Documentation
- int omp_get_num_threads()
Function omp_get_thread_num
Defined in File ewald.h
Function Documentation
- int omp_get_thread_num()
Variables
Variable deepmd::ElectrostaticConvertion
Defined in File ewald.h
Variable Documentation
- const double deepmd::ElectrostaticConvertion = 14.39964535475696995031
Defines
Define DPErrcheck
Defined in File gpu_cuda.h
Define Documentation
- DPErrcheck(res)
Define DPErrcheck
Defined in File gpu_rocm.h
Define Documentation
- DPErrcheck(res)
Define GPU_MAX_NBOR_SIZE
Defined in File gpu_cuda.h
Define Documentation
- GPU_MAX_NBOR_SIZE
Define GPU_MAX_NBOR_SIZE
Defined in File gpu_rocm.h
Define Documentation
- GPU_MAX_NBOR_SIZE
Define MOASPNDIM
Defined in File SimulationRegion.h
Define Documentation
- MOASPNDIM
Define nborErrcheck
Defined in File gpu_cuda.h
Define Documentation
- nborErrcheck(res)
Define nborErrcheck
Defined in File gpu_rocm.h
Define Documentation
- nborErrcheck(res)
Define SQRT_2_PI
Defined in File device.h
Define Documentation
- SQRT_2_PI
Define TPB
Defined in File device.h
Define Documentation
- TPB
Typedefs
Typedef int_64
Defined in File device.h
Typedef Documentation
- typedef long long int_64
Typedef uint_64
Defined in File device.h
Typedef Documentation
- typedef unsigned long long uint_64
License
The project DeePMD-kit is licensed under GNU LGPLv3.0.