deepmd.dpmodel.fitting.invar_fitting
====================================

.. py:module:: deepmd.dpmodel.fitting.invar_fitting


Classes
-------

.. autoapisummary::

   deepmd.dpmodel.fitting.invar_fitting.InvarFitting


Module Contents
---------------

.. py:class:: InvarFitting(var_name: str, ntypes: int, dim_descrpt: int, dim_out: int, neuron: list[int] = [120, 120, 120], resnet_dt: bool = True, numb_fparam: int = 0, numb_aparam: int = 0, dim_case_embd: int = 0, bias_atom: deepmd.dpmodel.array_api.Array | None = None, rcond: float | None = None, tot_ener_zero: bool = False, trainable: list[bool] | None = None, atom_ener: list[float] | None = None, activation_function: str = 'tanh', precision: str = DEFAULT_PRECISION, layer_name: list[str | None] | None = None, use_aparam_as_mask: bool = False, spin: Any = None, mixed_types: bool = True, exclude_types: list[int] = [], type_map: list[str] | None = None, seed: int | list[int] | None = None, default_fparam: list[float] | None = None)

   Bases: :py:obj:`deepmd.dpmodel.fitting.general_fitting.GeneralFitting`


   
   Fitting the energy (or a rotationally invariant property of `dim_out`) of the system. The force and the virial can also be trained.

   Lets take the energy fitting task as an example.
   The potential energy :math:`E` is a fitting network function of the descriptor :math:`\mathcal{D}`:

   .. math::
       E(\mathcal{D}) = \mathcal{L}^{(n)} \circ \mathcal{L}^{(n-1)}
       \circ \cdots \circ \mathcal{L}^{(1)} \circ \mathcal{L}^{(0)}

   The first :math:`n` hidden layers :math:`\mathcal{L}^{(0)}, \cdots, \mathcal{L}^{(n-1)}` are given by

   .. math::
       \mathbf{y}=\mathcal{L}(\mathbf{x};\mathbf{w},\mathbf{b})=
           \boldsymbol{\phi}(\mathbf{x}^T\mathbf{w}+\mathbf{b})

   where :math:`\mathbf{x} \in \mathbb{R}^{N_1}` is the input vector and :math:`\mathbf{y} \in \mathbb{R}^{N_2}`
   is the output vector. :math:`\mathbf{w} \in \mathbb{R}^{N_1 \times N_2}` and
   :math:`\mathbf{b} \in \mathbb{R}^{N_2}` are weights and biases, respectively,
   both of which are trainable if `trainable[i]` is `True`. :math:`\boldsymbol{\phi}`
   is the activation function.

   The output layer :math:`\mathcal{L}^{(n)}` is given by

   .. math::
       \mathbf{y}=\mathcal{L}^{(n)}(\mathbf{x};\mathbf{w},\mathbf{b})=
           \mathbf{x}^T\mathbf{w}+\mathbf{b}

   where :math:`\mathbf{x} \in \mathbb{R}^{N_{n-1}}` is the input vector and :math:`\mathbf{y} \in \mathbb{R}`
   is the output scalar. :math:`\mathbf{w} \in \mathbb{R}^{N_{n-1}}` and
   :math:`\mathbf{b} \in \mathbb{R}` are weights and bias, respectively,
   both of which are trainable if `trainable[n]` is `True`.

   :Parameters:

       **var_name**
           The name of the output variable.

       **ntypes**
           The number of atom types.

       **dim_descrpt**
           The dimension of the input descriptor.

       **dim_out**
           The dimension of the output fit property.

       **neuron**
           Number of neurons :math:`N` in each hidden layer of the fitting net

       **resnet_dt**
           Time-step `dt` in the resnet construction:
           :math:`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.

       **bias_atom**
           Bias for each element.

       **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 :math:`N_l` hidden layers in the fitting net,
           this list is of length :math:`N_l + 1`, specifying if the hidden layers and the output layer are trainable.

       **atom_ener**
           Specifying atomic energy contribution in vacuum. The `set_davg_zero` key in the descriptor should be set.

       **activation_function**
           The activation function :math:`\boldsymbol{\phi}` in the embedding net. Supported options are |ACTIVATION_FN|

       **precision**
           The precision of the embedding net parameters. Supported options are |PRECISION|

       **layer_name** : :class:`python:list`\[:obj:`Optional <typing.Optional>`\[:class:`python:str`]], :obj:`optional`
           The name of the each layer. If two layers, either in the same fitting or different fittings,
           have the same name, they will share the same neural network parameters.

       **use_aparam_as_mask: bool, optional**
           If True, the atomic parameters will be used as a mask that determines the atom is real/virtual.
           And the aparam will not be used as the atomic parameters for embedding.

       **mixed_types**
           If false, different atomic types uses different fitting net, otherwise different atom types share the same fitting net.

       **exclude_types: list[int]**
           Atomic contributions of the excluded atom types are set zero.

       **type_map: list[str], Optional**
           A list of strings. Give the name to each type of atoms.

       **default_fparam: list[float], optional**
           The default frame parameter. If set, when `fparam.npy` files are not included in the data system,
           this value will be used as the default value for the frame parameter in the fitting net.














   ..
       !! processed by numpydoc !!

   .. py:attribute:: dim_out


   .. py:attribute:: atom_ener
      :value: None



   .. py:method:: serialize() -> dict

      
      Serialize the fitting to dict.
















      ..
          !! processed by numpydoc !!


   .. py:method:: deserialize(data: dict) -> deepmd.dpmodel.fitting.general_fitting.GeneralFitting
      :classmethod:


      
      Deserialize the fitting.


      :Parameters:

          **data** : :class:`python:dict`
              The serialized data



      :Returns:

          :obj:`BF`
              The deserialized fitting











      ..
          !! processed by numpydoc !!


   .. py:method:: _net_out_dim() -> int

      
      Set the FittingNet output dim.
















      ..
          !! processed by numpydoc !!


   .. py:method:: compute_output_stats(merged: Any) -> NoReturn
      :abstractmethod:


      
      Update the output bias for fitting net.
















      ..
          !! processed by numpydoc !!


   .. py:method:: output_def() -> deepmd.dpmodel.output_def.FittingOutputDef

      
      Returns the output def of the fitting net.
















      ..
          !! processed by numpydoc !!


   .. py:method:: call(descriptor: deepmd.dpmodel.array_api.Array, atype: deepmd.dpmodel.array_api.Array, gr: deepmd.dpmodel.array_api.Array | None = None, g2: deepmd.dpmodel.array_api.Array | None = None, h2: deepmd.dpmodel.array_api.Array | None = None, fparam: deepmd.dpmodel.array_api.Array | None = None, aparam: deepmd.dpmodel.array_api.Array | None = None) -> dict[str, deepmd.dpmodel.array_api.Array]

      
      Calculate the fitting.


      :Parameters:

          **descriptor**
              input descriptor. shape: nf x nloc x nd

          **atype**
              the atom type. shape: nf x nloc

          **gr**
              The rotationally equivariant and permutationally invariant single particle
              representation. shape: nf x nloc x ng x 3

          **g2**
              The rotationally invariant pair-partical representation.
              shape: nf x nloc x nnei x ng

          **h2**
              The rotationally equivariant pair-partical representation.
              shape: nf x nloc x nnei x 3

          **fparam**
              The frame parameter. shape: nf x nfp. nfp being `numb_fparam`

          **aparam**
              The atomic parameter. shape: nf x nloc x nap. nap being `numb_aparam`














      ..
          !! processed by numpydoc !!