diff --git a/.gitignore b/.gitignore index 435a560708..b392cdbca5 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,5 @@ dist _version.py venv* .vscode/** +_build +_templates diff --git a/doc/Makefile b/doc/Makefile new file mode 100644 index 0000000000..d4bb2cbb9e --- /dev/null +++ b/doc/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/doc/_static/css/custom.css b/doc/_static/css/custom.css new file mode 100644 index 0000000000..120e099e0e --- /dev/null +++ b/doc/_static/css/custom.css @@ -0,0 +1,3 @@ +pre{ + overflow: auto; +} diff --git a/doc/api.rst b/doc/api.rst new file mode 100644 index 0000000000..17604ae010 --- /dev/null +++ b/doc/api.rst @@ -0,0 +1,91 @@ +DeePMD-kit API +=============== + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + +.. automodule:: deepmd.Data + :members: + :undoc-members: + +.. automodule:: deepmd.DataModifier + :members: + :undoc-members: + +.. automodule:: deepmd.DataSystem + :members: + :undoc-members: + +.. automodule:: deepmd.DeepDipole + :members: + :undoc-members: + +.. automodule:: deepmd.DeepEval + :members: + :undoc-members: + +.. automodule:: deepmd.DeepPolar + :members: + :undoc-members: + +.. automodule:: deepmd.DeepPot + :members: + :undoc-members: + +.. automodule:: deepmd.DeepWFC + :members: + :undoc-members: + +.. automodule:: deepmd.DescrptLocFrame + :members: + :undoc-members: + +.. automodule:: deepmd.DescrptSeA + :members: + :undoc-members: + +.. automodule:: deepmd.DescrptSeAR + :members: + :undoc-members: + +.. automodule:: deepmd.DescrptSeR + :members: + :undoc-members: + +.. automodule:: deepmd.EwaldRecp + :members: + :undoc-members: + +.. automodule:: deepmd.Fitting + :members: + :undoc-members: + +.. automodule:: deepmd.LearningRate + :members: + :undoc-members: + +.. automodule:: deepmd.Local + :members: + :undoc-members: + +.. automodule:: deepmd.Loss + :members: + :undoc-members: + +.. automodule:: deepmd.Model + :members: + :undoc-members: + +.. automodule:: deepmd.Network + :members: + :undoc-members: + +.. automodule:: deepmd.TabInter + :members: + :undoc-members: + +.. automodule:: deepmd.Trainer + :members: + :undoc-members: + diff --git a/doc/conf.py b/doc/conf.py new file mode 100644 index 0000000000..b757da9771 --- /dev/null +++ b/doc/conf.py @@ -0,0 +1,60 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +project = 'DeePMD-kit' +copyright = '2020, Deep Potential' +author = 'Deep Potential' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'recommonmark', + "sphinx_rtd_theme", + 'sphinx.ext.autosummary' +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] +html_css_files = ['css/custom.css'] + +autodoc_default_flags = ['members'] +autosummary_generate = True +master_doc = 'index' diff --git a/doc/index.rst b/doc/index.rst new file mode 100644 index 0000000000..13c0c45b7d --- /dev/null +++ b/doc/index.rst @@ -0,0 +1,26 @@ +.. deepmd-kit documentation master file, created by + sphinx-quickstart on Sat Nov 21 18:36:24 2020. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +DeePMD-kit's documentation +====================================== + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + + + install + use-deepmd-kit + train-input + lammps-pair-style-deepmd + api + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/doc/install.md b/doc/install.md index cf5ddbddbd..5e00d3275a 100644 --- a/doc/install.md +++ b/doc/install.md @@ -126,7 +126,7 @@ gcc --version 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.9. -First the C++ interface of Tensorflow should be installed. It is noted that the version of Tensorflow should be in consistent with the python interface. We assume that you have followed our instruction and installed tensorflow python interface 1.14.0 with, then you may follow [the instruction for CPU](doc/install-tf.1.14.md) to install the corresponding C++ interface (CPU only). If one wants GPU supports, he/she should follow [the instruction for GPU](doc/install-tf.1.14-gpu.md) to install the C++ interface. +First the C++ interface of Tensorflow should be installed. It is noted that the version of Tensorflow should be in consistent with the python interface. We assume that you have followed our instruction and installed tensorflow python interface 1.14.0 with, then you may follow [the instruction for CPU](install-tf.1.14.md) to install the corresponding C++ interface (CPU only). If one wants GPU supports, he/she should follow [the instruction for GPU](install-tf.1.14-gpu.md) to install the C++ interface. ### Install the DeePMD-kit's C++ interface diff --git a/doc/make.bat b/doc/make.bat new file mode 100644 index 0000000000..2119f51099 --- /dev/null +++ b/doc/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/doc/requirements.txt b/doc/requirements.txt new file mode 100644 index 0000000000..1d39662bb4 --- /dev/null +++ b/doc/requirements.txt @@ -0,0 +1 @@ +.[docs,cpu] diff --git a/doc/train-input-auto.rst b/doc/train-input-auto.rst new file mode 100644 index 0000000000..e29dd5799b --- /dev/null +++ b/doc/train-input-auto.rst @@ -0,0 +1,1023 @@ +.. raw:: html + + +model: + | type: ``dict`` + | argument path: ``model`` + + .. raw:: html + + + type_map: + | type: ``list``, optional + | argument path: ``model/type_map`` + + A list of strings. Give the name to each type of atoms. + + .. raw:: html + + + data_stat_nbatch: + | type: ``int``, optional, default: ``10`` + | argument path: ``model/data_stat_nbatch`` + + The model determines the normalization from the statistics of the data. This key specifies the number of `frames` in each `system` used for statistics. + + .. raw:: html + + + descriptor: + | type: ``dict`` + | argument path: ``model/descriptor`` + + The descriptor of atomic environment. + + + Depending on the value of *type*, different sub args are accepted. + + .. raw:: html + + + type: + | type: ``str`` (flag key) + | argument path: ``model/descriptor/type`` + + The type of the descritpor. Valid types are `loc_frame`, `se_a`, `se_r` and `se_ar`. + + - `loc_frame`: Defines a local frame at each atom, and the compute the descriptor as local coordinates under this frame. + + - `se_a`: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor. + + - `se_r`: Used by the smooth edition of Deep Potential. Only the distance between atoms is used to construct the descriptor. + + - `se_ar`: A hybrid of `se_a` and `se_r`. Typically `se_a` has a smaller cut-off while the `se_r` has a larger cut-off. + + + .. raw:: html + + + When *type* is set to ``loc_frame``: + + .. raw:: html + + + sel_a: + | type: ``list`` + | argument path: ``model/descriptor[loc_frame]/sel_a`` + + 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 selected number of type-i neighbors. The full relative coordinates of the neighbors are used by the descriptor. + + .. raw:: html + + + sel_r: + | type: ``list`` + | argument path: ``model/descriptor[loc_frame]/sel_r`` + + A 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. + + .. raw:: html + + + rcut: + | type: ``float``, optional, default: ``6.0`` + | argument path: ``model/descriptor[loc_frame]/rcut`` + + The cut-off radius. The default value is 6.0 + + .. raw:: html + + + axis_rule: + | type: ``list`` + | argument path: ``model/descriptor[loc_frame]/axis_rule`` + + A 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 first 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]: 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. + + + .. raw:: html + + + When *type* is set to ``se_a``: + + .. raw:: html + + + sel: + | type: ``list`` + | argument path: ``model/descriptor[se_a]/sel`` + + A list of integers. 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. + + .. raw:: html + + + rcut: + | type: ``float``, optional, default: ``6.0`` + | argument path: ``model/descriptor[se_a]/rcut`` + + The cut-off radius. + + .. raw:: html + + + rcut_smth: + | type: ``float``, optional, default: ``0.5`` + | argument path: ``model/descriptor[se_a]/rcut_smth`` + + Where to start smoothing. For example the 1/r term is smoothed from `rcut` to `rcut_smth` + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[10, 20, 40]`` + | argument path: ``model/descriptor[se_a]/neuron`` + + Number 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. + + .. raw:: html + + + axis_neuron: + | type: ``int``, optional, default: ``4`` + | argument path: ``model/descriptor[se_a]/axis_neuron`` + + Size of the submatrix of G (embedding matrix). + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/descriptor[se_a]/activation_function`` + + The activation function in the embedding net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_a]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + type_one_side: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_a]/type_one_side`` + + Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/descriptor[se_a]/precision`` + + The precision of the embedding net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + trainable: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/descriptor[se_a]/trainable`` + + If the parameters in the embedding net is trainable + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/descriptor[se_a]/seed`` + + Random seed for parameter initialization + + .. raw:: html + + + exclude_types: + | type: ``list``, optional, default: ``[]`` + | argument path: ``model/descriptor[se_a]/exclude_types`` + + The Excluded types + + .. raw:: html + + + set_davg_zero: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_a]/set_davg_zero`` + + Set the normalization average to zero. This option should be set when `atom_ener` in the energy fitting is used + + + .. raw:: html + + + When *type* is set to ``se_r``: + + .. raw:: html + + + sel: + | type: ``list`` + | argument path: ``model/descriptor[se_r]/sel`` + + A list of integers. 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. + + .. raw:: html + + + rcut: + | type: ``float``, optional, default: ``6.0`` + | argument path: ``model/descriptor[se_r]/rcut`` + + The cut-off radius. + + .. raw:: html + + + rcut_smth: + | type: ``float``, optional, default: ``0.5`` + | argument path: ``model/descriptor[se_r]/rcut_smth`` + + Where to start smoothing. For example the 1/r term is smoothed from `rcut` to `rcut_smth` + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[10, 20, 40]`` + | argument path: ``model/descriptor[se_r]/neuron`` + + Number 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. + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/descriptor[se_r]/activation_function`` + + The activation function in the embedding net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_r]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + type_one_side: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_r]/type_one_side`` + + Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/descriptor[se_r]/precision`` + + The precision of the embedding net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + trainable: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/descriptor[se_r]/trainable`` + + If the parameters in the embedding net is trainable + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/descriptor[se_r]/seed`` + + Random seed for parameter initialization + + .. raw:: html + + + exclude_types: + | type: ``list``, optional, default: ``[]`` + | argument path: ``model/descriptor[se_r]/exclude_types`` + + The Excluded types + + .. raw:: html + + + set_davg_zero: + | type: ``bool``, optional, default: ``False`` + | argument path: ``model/descriptor[se_r]/set_davg_zero`` + + Set the normalization average to zero. This option should be set when `atom_ener` in the energy fitting is used + + + .. raw:: html + + + When *type* is set to ``se_ar``: + + .. raw:: html + + + a: + | type: ``dict`` + | argument path: ``model/descriptor[se_ar]/a`` + + The parameters of descriptor `se_a <#model/descriptor[se_a]>`__ + + .. raw:: html + + + r: + | type: ``dict`` + | argument path: ``model/descriptor[se_ar]/r`` + + The parameters of descriptor `se_r <#model/descriptor[se_r]>`__ + + .. raw:: html + + + fitting_net: + | type: ``dict`` + | argument path: ``model/fitting_net`` + + The fitting of physical properties. + + + Depending on the value of *type*, different sub args are accepted. + + .. raw:: html + + + type: + | type: ``str`` (flag key), default: ``ener`` + | argument path: ``model/fitting_net/type`` + + The type of the fitting. Valid types are `ener`, `dipole`, `polar` and `global_polar`. + + - `ener`: Fit an energy model (potential energy surface). + + - `dipole`: Fit an atomic dipole model. Atomic dipole labels for all the selected atoms (see `sel_type`) should be provided by `dipole.npy` in each data system. The file has number of frames lines and 3 times of number of selected atoms columns. + + - `polar`: Fit an atomic polarizability model. Atomic polarizability labels for all the selected atoms (see `sel_type`) should be provided by `polarizability.npy` in each data system. The file has number of frames lines and 9 times of number of selected atoms columns. + + - `global_polar`: Fit a polarizability model. Polarizability labels should be provided by `polarizability.npy` in each data system. The file has number of frames lines and 9 columns. + + + .. raw:: html + + + When *type* is set to ``ener``: + + .. raw:: html + + + numb_fparam: + | type: ``int``, optional, default: ``0`` + | argument path: ``model/fitting_net[ener]/numb_fparam`` + + The dimension of the frame parameter. If set to >0, file `fparam.npy` should be included to provided the input fparams. + + .. raw:: html + + + numb_aparam: + | type: ``int``, optional, default: ``0`` + | argument path: ``model/fitting_net[ener]/numb_aparam`` + + The dimension of the atomic parameter. If set to >0, file `aparam.npy` should be included to provided the input aparams. + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[120, 120, 120]`` + | argument path: ``model/fitting_net[ener]/neuron`` + + The 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. + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/fitting_net[ener]/activation_function`` + + The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/fitting_net[ener]/precision`` + + The precision of the fitting net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[ener]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + trainable: + | type: ``bool`` | ``list``, optional, default: ``True`` + | argument path: ``model/fitting_net[ener]/trainable`` + + Whether 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. + + .. raw:: html + + + rcond: + | type: ``float``, optional, default: ``0.001`` + | argument path: ``model/fitting_net[ener]/rcond`` + + The condition number used to determine the inital energy shift for each type of atoms. + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/fitting_net[ener]/seed`` + + Random seed for parameter initialization of the fitting net + + .. raw:: html + + + atom_ener: + | type: ``list``, optional, default: ``[]`` + | argument path: ``model/fitting_net[ener]/atom_ener`` + + Specify the atomic energy in vacuum for each type + + + .. raw:: html + + + When *type* is set to ``dipole``: + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[120, 120, 120]`` + | argument path: ``model/fitting_net[dipole]/neuron`` + + The 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. + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/fitting_net[dipole]/activation_function`` + + The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[dipole]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/fitting_net[dipole]/precision`` + + The precision of the fitting net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + sel_type: + | type: ``int`` | ``NoneType`` | ``list``, optional + | argument path: ``model/fitting_net[dipole]/sel_type`` + + The atom types for which the atomic dipole will be provided. If not set, all types will be selected. + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/fitting_net[dipole]/seed`` + + Random seed for parameter initialization of the fitting net + + + .. raw:: html + + + When *type* is set to ``polar``: + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[120, 120, 120]`` + | argument path: ``model/fitting_net[polar]/neuron`` + + The 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. + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/fitting_net[polar]/activation_function`` + + The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[polar]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/fitting_net[polar]/precision`` + + The precision of the fitting net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + fit_diag: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[polar]/fit_diag`` + + Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix. + + .. raw:: html + + + scale: + | type: ``float`` | ``list``, optional, default: ``1.0`` + | argument path: ``model/fitting_net[polar]/scale`` + + The output of the fitting net (polarizability matrix) will be scaled by ``scale`` + + .. raw:: html + + + diag_shift: + | type: ``float`` | ``list``, optional, default: ``0.0`` + | argument path: ``model/fitting_net[polar]/diag_shift`` + + The diagonal part of the polarizability matrix will be shifted by ``diag_shift``. The shift operation is carried out after ``scale``. + + .. raw:: html + + + sel_type: + | type: ``int`` | ``NoneType`` | ``list``, optional + | argument path: ``model/fitting_net[polar]/sel_type`` + + The atom types for which the atomic polarizability will be provided. If not set, all types will be selected. + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/fitting_net[polar]/seed`` + + Random seed for parameter initialization of the fitting net + + + .. raw:: html + + + When *type* is set to ``global_polar``: + + .. raw:: html + + + neuron: + | type: ``list``, optional, default: ``[120, 120, 120]`` + | argument path: ``model/fitting_net[global_polar]/neuron`` + + The 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. + + .. raw:: html + + + activation_function: + | type: ``str``, optional, default: ``tanh`` + | argument path: ``model/fitting_net[global_polar]/activation_function`` + + The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". + + .. raw:: html + + + resnet_dt: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[global_polar]/resnet_dt`` + + Whether to use a "Timestep" in the skip connection + + .. raw:: html + + + precision: + | type: ``str``, optional, default: ``float64`` + | argument path: ``model/fitting_net[global_polar]/precision`` + + The precision of the fitting net parameters, supported options are "float64", "float32", "float16". + + .. raw:: html + + + fit_diag: + | type: ``bool``, optional, default: ``True`` + | argument path: ``model/fitting_net[global_polar]/fit_diag`` + + Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix. + + .. raw:: html + + + scale: + | type: ``float`` | ``list``, optional, default: ``1.0`` + | argument path: ``model/fitting_net[global_polar]/scale`` + + The output of the fitting net (polarizability matrix) will be scaled by ``scale`` + + .. raw:: html + + + diag_shift: + | type: ``float`` | ``list``, optional, default: ``0.0`` + | argument path: ``model/fitting_net[global_polar]/diag_shift`` + + The diagonal part of the polarizability matrix will be shifted by ``diag_shift``. The shift operation is carried out after ``scale``. + + .. raw:: html + + + sel_type: + | type: ``int`` | ``NoneType`` | ``list``, optional + | argument path: ``model/fitting_net[global_polar]/sel_type`` + + The atom types for which the atomic polarizability will be provided. If not set, all types will be selected. + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``model/fitting_net[global_polar]/seed`` + + Random seed for parameter initialization of the fitting net + + +.. raw:: html + + +loss: + | type: ``dict`` + | argument path: ``loss`` + + The definition of loss function. The type of the loss depends on the type of the fitting. For fitting type `ener`, the prefactors before energy, force, virial and atomic energy losses may be provided. For fitting type `dipole`, `polar` and `global_polar`, the loss may be an empty `dict` or unset. + + + Depending on the value of *type*, different sub args are accepted. + + .. raw:: html + + + type: + | type: ``str`` (flag key), default: ``ener`` + | argument path: ``loss/type`` + + The type of the loss. For fitting type `ener`, the loss type should be set to `ener` or left unset. For tensorial fitting types `dipole`, `polar` and `global_polar`, the type should be left unset. + \. + + + .. raw:: html + + + When *type* is set to ``ener``: + + .. raw:: html + + + start_pref_e: + | type: ``float`` | ``int``, optional, default: ``0.02`` + | argument path: ``loss[ener]/start_pref_e`` + + The 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. + + .. raw:: html + + + limit_pref_e: + | type: ``float`` | ``int``, optional, default: ``1.0`` + | argument path: ``loss[ener]/limit_pref_e`` + + The 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. + + .. raw:: html + + + start_pref_f: + | type: ``float`` | ``int``, optional, default: ``1000`` + | argument path: ``loss[ener]/start_pref_f`` + + The 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. + + .. raw:: html + + + limit_pref_f: + | type: ``float`` | ``int``, optional, default: ``1.0`` + | argument path: ``loss[ener]/limit_pref_f`` + + The 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. + + .. raw:: html + + + start_pref_v: + | type: ``float`` | ``int``, optional, default: ``0.0`` + | argument path: ``loss[ener]/start_pref_v`` + + The 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. + + .. raw:: html + + + limit_pref_v: + | type: ``float`` | ``int``, optional, default: ``0.0`` + | argument path: ``loss[ener]/limit_pref_v`` + + The 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. + + .. raw:: html + + + start_pref_ae: + | type: ``float`` | ``int``, optional, default: ``0.0`` + | argument path: ``loss[ener]/start_pref_ae`` + + The 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. + + .. raw:: html + + + limit_pref_ae: + | type: ``float`` | ``int``, optional, default: ``0.0`` + | argument path: ``loss[ener]/limit_pref_ae`` + + The 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. + + .. raw:: html + + + relative_f: + | type: ``float`` | ``NoneType``, optional + | argument path: ``loss[ener]/relative_f`` + + If 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. + + +.. raw:: html + + +learning_rate: + | type: ``dict`` + | argument path: ``learning_rate`` + + The learning rate options + + .. raw:: html + + + start_lr: + | type: ``float``, optional, default: ``0.001`` + | argument path: ``learning_rate/start_lr`` + + The learning rate the start of the training. + + .. raw:: html + + + stop_lr: + | type: ``float``, optional, default: ``1e-08`` + | argument path: ``learning_rate/stop_lr`` + + The desired learning rate at the end of the training. + + .. raw:: html + + + decay_steps: + | type: ``int``, optional, default: ``5000`` + | argument path: ``learning_rate/decay_steps`` + + The learning rate is decaying every this number of training steps. + + +.. raw:: html + + +training: + | type: ``dict`` + | argument path: ``training`` + + The training options + + .. raw:: html + + + systems: + | type: ``list`` | ``str`` + | argument path: ``training/systems`` + + The data systems. This key can be provided with a listthat 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. + + .. raw:: html + + + set_prefix: + | type: ``str``, optional, default: ``set`` + | argument path: ``training/set_prefix`` + + The prefix of the sets in the systems. + + .. raw:: html + + + stop_batch: + | type: ``int`` + | argument path: ``training/stop_batch`` + + Number of training batch. Each training uses one batch of data. + + .. raw:: html + + + batch_size: + | type: ``int`` | ``list`` | ``str``, optional, default: ``auto`` + | argument path: ``training/batch_size`` + + This 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` uses the same batch size. + + - string "auto": automatically determines the batch size os 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 os that the batch_size times the number of atoms in the system is no less than N. + + .. raw:: html + + + seed: + | type: ``int`` | ``NoneType``, optional + | argument path: ``training/seed`` + + The random seed for training. + + .. raw:: html + + + disp_file: + | type: ``str``, optional, default: ``lcueve.out`` + | argument path: ``training/disp_file`` + + The file for printing learning curve. + + .. raw:: html + + + disp_freq: + | type: ``int``, optional, default: ``1000`` + | argument path: ``training/disp_freq`` + + The frequency of printing learning curve. + + .. raw:: html + + + numb_test: + | type: ``int``, optional, default: ``1`` + | argument path: ``training/numb_test`` + + Number of frames used for the test during training. + + .. raw:: html + + + save_freq: + | type: ``int``, optional, default: ``1000`` + | argument path: ``training/save_freq`` + + The frequency of saving check point. + + .. raw:: html + + + save_ckpt: + | type: ``str``, optional, default: ``model.ckpt`` + | argument path: ``training/save_ckpt`` + + The file name of saving check point. + + .. raw:: html + + + disp_training: + | type: ``bool``, optional, default: ``True`` + | argument path: ``training/disp_training`` + + Displaying verbose information during training. + + .. raw:: html + + + time_training: + | type: ``bool``, optional, default: ``True`` + | argument path: ``training/time_training`` + + Timing durining training. + + .. raw:: html + + + profiling: + | type: ``bool``, optional, default: ``False`` + | argument path: ``training/profiling`` + + Profiling during training. + + .. raw:: html + + + profiling_file: + | type: ``str``, optional, default: ``timeline.json`` + | argument path: ``training/profiling_file`` + + Output file for profiling. + diff --git a/doc/train-input.rst b/doc/train-input.rst index e29dd5799b..aa6c7bd01e 100644 --- a/doc/train-input.rst +++ b/doc/train-input.rst @@ -1,1023 +1,3 @@ -.. raw:: html - - -model: - | type: ``dict`` - | argument path: ``model`` - - .. raw:: html - - - type_map: - | type: ``list``, optional - | argument path: ``model/type_map`` - - A list of strings. Give the name to each type of atoms. - - .. raw:: html - - - data_stat_nbatch: - | type: ``int``, optional, default: ``10`` - | argument path: ``model/data_stat_nbatch`` - - The model determines the normalization from the statistics of the data. This key specifies the number of `frames` in each `system` used for statistics. - - .. raw:: html - - - descriptor: - | type: ``dict`` - | argument path: ``model/descriptor`` - - The descriptor of atomic environment. - - - Depending on the value of *type*, different sub args are accepted. - - .. raw:: html - - - type: - | type: ``str`` (flag key) - | argument path: ``model/descriptor/type`` - - The type of the descritpor. Valid types are `loc_frame`, `se_a`, `se_r` and `se_ar`. - - - `loc_frame`: Defines a local frame at each atom, and the compute the descriptor as local coordinates under this frame. - - - `se_a`: Used by the smooth edition of Deep Potential. The full relative coordinates are used to construct the descriptor. - - - `se_r`: Used by the smooth edition of Deep Potential. Only the distance between atoms is used to construct the descriptor. - - - `se_ar`: A hybrid of `se_a` and `se_r`. Typically `se_a` has a smaller cut-off while the `se_r` has a larger cut-off. - - - .. raw:: html - - - When *type* is set to ``loc_frame``: - - .. raw:: html - - - sel_a: - | type: ``list`` - | argument path: ``model/descriptor[loc_frame]/sel_a`` - - 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 selected number of type-i neighbors. The full relative coordinates of the neighbors are used by the descriptor. - - .. raw:: html - - - sel_r: - | type: ``list`` - | argument path: ``model/descriptor[loc_frame]/sel_r`` - - A 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. - - .. raw:: html - - - rcut: - | type: ``float``, optional, default: ``6.0`` - | argument path: ``model/descriptor[loc_frame]/rcut`` - - The cut-off radius. The default value is 6.0 - - .. raw:: html - - - axis_rule: - | type: ``list`` - | argument path: ``model/descriptor[loc_frame]/axis_rule`` - - A 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 first 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]: 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. - - - .. raw:: html - - - When *type* is set to ``se_a``: - - .. raw:: html - - - sel: - | type: ``list`` - | argument path: ``model/descriptor[se_a]/sel`` - - A list of integers. 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. - - .. raw:: html - - - rcut: - | type: ``float``, optional, default: ``6.0`` - | argument path: ``model/descriptor[se_a]/rcut`` - - The cut-off radius. - - .. raw:: html - - - rcut_smth: - | type: ``float``, optional, default: ``0.5`` - | argument path: ``model/descriptor[se_a]/rcut_smth`` - - Where to start smoothing. For example the 1/r term is smoothed from `rcut` to `rcut_smth` - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[10, 20, 40]`` - | argument path: ``model/descriptor[se_a]/neuron`` - - Number 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. - - .. raw:: html - - - axis_neuron: - | type: ``int``, optional, default: ``4`` - | argument path: ``model/descriptor[se_a]/axis_neuron`` - - Size of the submatrix of G (embedding matrix). - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/descriptor[se_a]/activation_function`` - - The activation function in the embedding net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_a]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - type_one_side: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_a]/type_one_side`` - - Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/descriptor[se_a]/precision`` - - The precision of the embedding net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - trainable: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/descriptor[se_a]/trainable`` - - If the parameters in the embedding net is trainable - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/descriptor[se_a]/seed`` - - Random seed for parameter initialization - - .. raw:: html - - - exclude_types: - | type: ``list``, optional, default: ``[]`` - | argument path: ``model/descriptor[se_a]/exclude_types`` - - The Excluded types - - .. raw:: html - - - set_davg_zero: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_a]/set_davg_zero`` - - Set the normalization average to zero. This option should be set when `atom_ener` in the energy fitting is used - - - .. raw:: html - - - When *type* is set to ``se_r``: - - .. raw:: html - - - sel: - | type: ``list`` - | argument path: ``model/descriptor[se_r]/sel`` - - A list of integers. 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. - - .. raw:: html - - - rcut: - | type: ``float``, optional, default: ``6.0`` - | argument path: ``model/descriptor[se_r]/rcut`` - - The cut-off radius. - - .. raw:: html - - - rcut_smth: - | type: ``float``, optional, default: ``0.5`` - | argument path: ``model/descriptor[se_r]/rcut_smth`` - - Where to start smoothing. For example the 1/r term is smoothed from `rcut` to `rcut_smth` - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[10, 20, 40]`` - | argument path: ``model/descriptor[se_r]/neuron`` - - Number 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. - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/descriptor[se_r]/activation_function`` - - The activation function in the embedding net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_r]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - type_one_side: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_r]/type_one_side`` - - Try to build N_types embedding nets. Otherwise, building N_types^2 embedding nets - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/descriptor[se_r]/precision`` - - The precision of the embedding net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - trainable: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/descriptor[se_r]/trainable`` - - If the parameters in the embedding net is trainable - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/descriptor[se_r]/seed`` - - Random seed for parameter initialization - - .. raw:: html - - - exclude_types: - | type: ``list``, optional, default: ``[]`` - | argument path: ``model/descriptor[se_r]/exclude_types`` - - The Excluded types - - .. raw:: html - - - set_davg_zero: - | type: ``bool``, optional, default: ``False`` - | argument path: ``model/descriptor[se_r]/set_davg_zero`` - - Set the normalization average to zero. This option should be set when `atom_ener` in the energy fitting is used - - - .. raw:: html - - - When *type* is set to ``se_ar``: - - .. raw:: html - - - a: - | type: ``dict`` - | argument path: ``model/descriptor[se_ar]/a`` - - The parameters of descriptor `se_a <#model/descriptor[se_a]>`__ - - .. raw:: html - - - r: - | type: ``dict`` - | argument path: ``model/descriptor[se_ar]/r`` - - The parameters of descriptor `se_r <#model/descriptor[se_r]>`__ - - .. raw:: html - - - fitting_net: - | type: ``dict`` - | argument path: ``model/fitting_net`` - - The fitting of physical properties. - - - Depending on the value of *type*, different sub args are accepted. - - .. raw:: html - - - type: - | type: ``str`` (flag key), default: ``ener`` - | argument path: ``model/fitting_net/type`` - - The type of the fitting. Valid types are `ener`, `dipole`, `polar` and `global_polar`. - - - `ener`: Fit an energy model (potential energy surface). - - - `dipole`: Fit an atomic dipole model. Atomic dipole labels for all the selected atoms (see `sel_type`) should be provided by `dipole.npy` in each data system. The file has number of frames lines and 3 times of number of selected atoms columns. - - - `polar`: Fit an atomic polarizability model. Atomic polarizability labels for all the selected atoms (see `sel_type`) should be provided by `polarizability.npy` in each data system. The file has number of frames lines and 9 times of number of selected atoms columns. - - - `global_polar`: Fit a polarizability model. Polarizability labels should be provided by `polarizability.npy` in each data system. The file has number of frames lines and 9 columns. - - - .. raw:: html - - - When *type* is set to ``ener``: - - .. raw:: html - - - numb_fparam: - | type: ``int``, optional, default: ``0`` - | argument path: ``model/fitting_net[ener]/numb_fparam`` - - The dimension of the frame parameter. If set to >0, file `fparam.npy` should be included to provided the input fparams. - - .. raw:: html - - - numb_aparam: - | type: ``int``, optional, default: ``0`` - | argument path: ``model/fitting_net[ener]/numb_aparam`` - - The dimension of the atomic parameter. If set to >0, file `aparam.npy` should be included to provided the input aparams. - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[120, 120, 120]`` - | argument path: ``model/fitting_net[ener]/neuron`` - - The 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. - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/fitting_net[ener]/activation_function`` - - The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/fitting_net[ener]/precision`` - - The precision of the fitting net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[ener]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - trainable: - | type: ``bool`` | ``list``, optional, default: ``True`` - | argument path: ``model/fitting_net[ener]/trainable`` - - Whether 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. - - .. raw:: html - - - rcond: - | type: ``float``, optional, default: ``0.001`` - | argument path: ``model/fitting_net[ener]/rcond`` - - The condition number used to determine the inital energy shift for each type of atoms. - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/fitting_net[ener]/seed`` - - Random seed for parameter initialization of the fitting net - - .. raw:: html - - - atom_ener: - | type: ``list``, optional, default: ``[]`` - | argument path: ``model/fitting_net[ener]/atom_ener`` - - Specify the atomic energy in vacuum for each type - - - .. raw:: html - - - When *type* is set to ``dipole``: - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[120, 120, 120]`` - | argument path: ``model/fitting_net[dipole]/neuron`` - - The 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. - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/fitting_net[dipole]/activation_function`` - - The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[dipole]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/fitting_net[dipole]/precision`` - - The precision of the fitting net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - sel_type: - | type: ``int`` | ``NoneType`` | ``list``, optional - | argument path: ``model/fitting_net[dipole]/sel_type`` - - The atom types for which the atomic dipole will be provided. If not set, all types will be selected. - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/fitting_net[dipole]/seed`` - - Random seed for parameter initialization of the fitting net - - - .. raw:: html - - - When *type* is set to ``polar``: - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[120, 120, 120]`` - | argument path: ``model/fitting_net[polar]/neuron`` - - The 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. - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/fitting_net[polar]/activation_function`` - - The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[polar]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/fitting_net[polar]/precision`` - - The precision of the fitting net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - fit_diag: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[polar]/fit_diag`` - - Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix. - - .. raw:: html - - - scale: - | type: ``float`` | ``list``, optional, default: ``1.0`` - | argument path: ``model/fitting_net[polar]/scale`` - - The output of the fitting net (polarizability matrix) will be scaled by ``scale`` - - .. raw:: html - - - diag_shift: - | type: ``float`` | ``list``, optional, default: ``0.0`` - | argument path: ``model/fitting_net[polar]/diag_shift`` - - The diagonal part of the polarizability matrix will be shifted by ``diag_shift``. The shift operation is carried out after ``scale``. - - .. raw:: html - - - sel_type: - | type: ``int`` | ``NoneType`` | ``list``, optional - | argument path: ``model/fitting_net[polar]/sel_type`` - - The atom types for which the atomic polarizability will be provided. If not set, all types will be selected. - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/fitting_net[polar]/seed`` - - Random seed for parameter initialization of the fitting net - - - .. raw:: html - - - When *type* is set to ``global_polar``: - - .. raw:: html - - - neuron: - | type: ``list``, optional, default: ``[120, 120, 120]`` - | argument path: ``model/fitting_net[global_polar]/neuron`` - - The 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. - - .. raw:: html - - - activation_function: - | type: ``str``, optional, default: ``tanh`` - | argument path: ``model/fitting_net[global_polar]/activation_function`` - - The activation function in the fitting net. Supported activation functions are "relu", "relu6", "softplus", "sigmoid", "tanh", "gelu". - - .. raw:: html - - - resnet_dt: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[global_polar]/resnet_dt`` - - Whether to use a "Timestep" in the skip connection - - .. raw:: html - - - precision: - | type: ``str``, optional, default: ``float64`` - | argument path: ``model/fitting_net[global_polar]/precision`` - - The precision of the fitting net parameters, supported options are "float64", "float32", "float16". - - .. raw:: html - - - fit_diag: - | type: ``bool``, optional, default: ``True`` - | argument path: ``model/fitting_net[global_polar]/fit_diag`` - - Fit the diagonal part of the rotational invariant polarizability matrix, which will be converted to normal polarizability matrix by contracting with the rotation matrix. - - .. raw:: html - - - scale: - | type: ``float`` | ``list``, optional, default: ``1.0`` - | argument path: ``model/fitting_net[global_polar]/scale`` - - The output of the fitting net (polarizability matrix) will be scaled by ``scale`` - - .. raw:: html - - - diag_shift: - | type: ``float`` | ``list``, optional, default: ``0.0`` - | argument path: ``model/fitting_net[global_polar]/diag_shift`` - - The diagonal part of the polarizability matrix will be shifted by ``diag_shift``. The shift operation is carried out after ``scale``. - - .. raw:: html - - - sel_type: - | type: ``int`` | ``NoneType`` | ``list``, optional - | argument path: ``model/fitting_net[global_polar]/sel_type`` - - The atom types for which the atomic polarizability will be provided. If not set, all types will be selected. - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``model/fitting_net[global_polar]/seed`` - - Random seed for parameter initialization of the fitting net - - -.. raw:: html - - -loss: - | type: ``dict`` - | argument path: ``loss`` - - The definition of loss function. The type of the loss depends on the type of the fitting. For fitting type `ener`, the prefactors before energy, force, virial and atomic energy losses may be provided. For fitting type `dipole`, `polar` and `global_polar`, the loss may be an empty `dict` or unset. - - - Depending on the value of *type*, different sub args are accepted. - - .. raw:: html - - - type: - | type: ``str`` (flag key), default: ``ener`` - | argument path: ``loss/type`` - - The type of the loss. For fitting type `ener`, the loss type should be set to `ener` or left unset. For tensorial fitting types `dipole`, `polar` and `global_polar`, the type should be left unset. - \. - - - .. raw:: html - - - When *type* is set to ``ener``: - - .. raw:: html - - - start_pref_e: - | type: ``float`` | ``int``, optional, default: ``0.02`` - | argument path: ``loss[ener]/start_pref_e`` - - The 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. - - .. raw:: html - - - limit_pref_e: - | type: ``float`` | ``int``, optional, default: ``1.0`` - | argument path: ``loss[ener]/limit_pref_e`` - - The 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. - - .. raw:: html - - - start_pref_f: - | type: ``float`` | ``int``, optional, default: ``1000`` - | argument path: ``loss[ener]/start_pref_f`` - - The 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. - - .. raw:: html - - - limit_pref_f: - | type: ``float`` | ``int``, optional, default: ``1.0`` - | argument path: ``loss[ener]/limit_pref_f`` - - The 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. - - .. raw:: html - - - start_pref_v: - | type: ``float`` | ``int``, optional, default: ``0.0`` - | argument path: ``loss[ener]/start_pref_v`` - - The 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. - - .. raw:: html - - - limit_pref_v: - | type: ``float`` | ``int``, optional, default: ``0.0`` - | argument path: ``loss[ener]/limit_pref_v`` - - The 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. - - .. raw:: html - - - start_pref_ae: - | type: ``float`` | ``int``, optional, default: ``0.0`` - | argument path: ``loss[ener]/start_pref_ae`` - - The 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. - - .. raw:: html - - - limit_pref_ae: - | type: ``float`` | ``int``, optional, default: ``0.0`` - | argument path: ``loss[ener]/limit_pref_ae`` - - The 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. - - .. raw:: html - - - relative_f: - | type: ``float`` | ``NoneType``, optional - | argument path: ``loss[ener]/relative_f`` - - If 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. - - -.. raw:: html - - -learning_rate: - | type: ``dict`` - | argument path: ``learning_rate`` - - The learning rate options - - .. raw:: html - - - start_lr: - | type: ``float``, optional, default: ``0.001`` - | argument path: ``learning_rate/start_lr`` - - The learning rate the start of the training. - - .. raw:: html - - - stop_lr: - | type: ``float``, optional, default: ``1e-08`` - | argument path: ``learning_rate/stop_lr`` - - The desired learning rate at the end of the training. - - .. raw:: html - - - decay_steps: - | type: ``int``, optional, default: ``5000`` - | argument path: ``learning_rate/decay_steps`` - - The learning rate is decaying every this number of training steps. - - -.. raw:: html - - -training: - | type: ``dict`` - | argument path: ``training`` - - The training options - - .. raw:: html - - - systems: - | type: ``list`` | ``str`` - | argument path: ``training/systems`` - - The data systems. This key can be provided with a listthat 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. - - .. raw:: html - - - set_prefix: - | type: ``str``, optional, default: ``set`` - | argument path: ``training/set_prefix`` - - The prefix of the sets in the systems. - - .. raw:: html - - - stop_batch: - | type: ``int`` - | argument path: ``training/stop_batch`` - - Number of training batch. Each training uses one batch of data. - - .. raw:: html - - - batch_size: - | type: ``int`` | ``list`` | ``str``, optional, default: ``auto`` - | argument path: ``training/batch_size`` - - This 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` uses the same batch size. - - - string "auto": automatically determines the batch size os 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 os that the batch_size times the number of atoms in the system is no less than N. - - .. raw:: html - - - seed: - | type: ``int`` | ``NoneType``, optional - | argument path: ``training/seed`` - - The random seed for training. - - .. raw:: html - - - disp_file: - | type: ``str``, optional, default: ``lcueve.out`` - | argument path: ``training/disp_file`` - - The file for printing learning curve. - - .. raw:: html - - - disp_freq: - | type: ``int``, optional, default: ``1000`` - | argument path: ``training/disp_freq`` - - The frequency of printing learning curve. - - .. raw:: html - - - numb_test: - | type: ``int``, optional, default: ``1`` - | argument path: ``training/numb_test`` - - Number of frames used for the test during training. - - .. raw:: html - - - save_freq: - | type: ``int``, optional, default: ``1000`` - | argument path: ``training/save_freq`` - - The frequency of saving check point. - - .. raw:: html - - - save_ckpt: - | type: ``str``, optional, default: ``model.ckpt`` - | argument path: ``training/save_ckpt`` - - The file name of saving check point. - - .. raw:: html - - - disp_training: - | type: ``bool``, optional, default: ``True`` - | argument path: ``training/disp_training`` - - Displaying verbose information during training. - - .. raw:: html - - - time_training: - | type: ``bool``, optional, default: ``True`` - | argument path: ``training/time_training`` - - Timing durining training. - - .. raw:: html - - - profiling: - | type: ``bool``, optional, default: ``False`` - | argument path: ``training/profiling`` - - Profiling during training. - - .. raw:: html - - - profiling_file: - | type: ``str``, optional, default: ``timeline.json`` - | argument path: ``training/profiling_file`` - - Output file for profiling. - +Training parameters +====================================== +.. include:: train-input-auto.rst diff --git a/setup.py b/setup.py index e03d2dcf7f..885022d196 100644 --- a/setup.py +++ b/setup.py @@ -80,6 +80,7 @@ cmake_minimum_required_version='3.0', extras_require={ 'test': ['dpdata>=0.1.9'], + 'docs': ['sphinx', 'recommonmark', 'sphinx_rtd_theme'], **extras_require, }, entry_points={