pd(feat): support python inference with DP class (#4987)

Summary:
1. support python inference with `DP(model=paddle_inference.json)` for
ase, and add an unitest.
2. update ase document with different backend
3. fix typos in `DeepPotPD.cc`


---
This pull request introduces significant enhancements and refactoring to
the Paddle backend implementation of `DeepEval` in
`deepmd/pd/infer/deep_eval.py`, along with minor improvements to model
freezing in `deepmd/pd/entrypoints/main.py`. The most important changes
are the addition of support for static models loaded from `.json` files,
expanded model type handling, and improved output shape and evaluation
logic for various model branches and output variable categories.

### Static model and inference support

* Added support for loading and evaluating static models from `.json`
files, including Paddle inference engine integration and input/output
handle management for efficient prediction.
(`deepmd/pd/infer/deep_eval.py`)
[[1]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68L117-R181)
[[2]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68R470)
[[3]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68R481-R508)
[[4]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68R532-R547)
[[5]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68L420-R566)

### Expanded model type and branch handling

* Enhanced model type detection to support additional output types such
as DOS, dipole, polar, global polar, WFC, and property models, with
corresponding evaluator selection. Also added methods for model branch
information retrieval and default parameter checks.
(`deepmd/pd/infer/deep_eval.py`)
[[1]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68L152-R259)
[[2]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68L187-R306)

### Output variable and evaluation improvements

* Improved output shape determination for new output variable categories
(e.g., `DERV_R_DERV_R`), and refactored evaluation logic to handle both
static and dynamic models, including proper output conversion.
(`deepmd/pd/infer/deep_eval.py`)
[[1]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68R412)
[[2]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68R681-R683)
[[3]](diffhunk://#diff-8c2ffd525a36d0190726f1aca380b9a4e05e67cd8ba6fa5e3842f810c69e6c68L420-R566)
* Implemented the previously unimplemented `_eval_model_spin` method to
support spin-dependent model evaluation and output extraction.
(`deepmd/pd/infer/deep_eval.py`)

### Type embedding evaluation

* Added a new method `eval_typeebd` to extract and concatenate type
embedding network outputs from the loaded model.
(`deepmd/pd/infer/deep_eval.py`)

### Model freezing improvements

* Updated the `freeze` function to support freezing additional model
methods and atomic virial computation, and changed input specifications
for better compatibility. (`deepmd/pd/entrypoints/main.py`)
[[1]](diffhunk://#diff-e3f56cd14511cf86a0db88d6d9ee5b08cf45374edfdef0625a0f519d94c58507R345)
[[2]](diffhunk://#diff-e3f56cd14511cf86a0db88d6d9ee5b08cf45374edfdef0625a0f519d94c58507L377-R378)
[[3]](diffhunk://#diff-e3f56cd14511cf86a0db88d6d9ee5b08cf45374edfdef0625a0f519d94c58507L393-R400)
[[4]](diffhunk://#diff-e3f56cd14511cf86a0db88d6d9ee5b08cf45374edfdef0625a0f519d94c58507R413-R432)

Let me know if you'd like a walkthrough of any specific new
functionality or code sections!

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- New Features
- Dual evaluation modes: dynamic (.json) and static (.pd) with optional
no-JIT; new evaluation branches for additional model types and spin
support.
- Freeze can include atomic virial; frozen exports expose additional
buffer-backed getters (type map, cutoffs, parameter dims, ntypes).

- Improvements
- Wider static-graph support via persistent buffers across
descriptors/models; more consistent inference input handling and
batching.

- Documentation
  - ASE guide extended with backend-specific examples.

- Tests
- New end-to-end training, inference, and frozen-model validation tests.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: HydrogenSulfate <490868991@qq.com>
Co-authored-by: Jinzhe Zeng <jinzhe.zeng@rutgers.edu>

Author: HydrogenSulfate

deepmd/pd/entrypoints/main.py

@@ -7,6 +7,7 @@
     Path,
 )
 from typing import (
+    Any,
     Optional,
     Union,
 )
@@ -80,15 +81,15 @@
 
 
 def get_trainer(
-    config,
-    init_model=None,
-    restart_model=None,
-    finetune_model=None,
-    force_load=False,
-    init_frz_model=None,
-    shared_links=None,
-    finetune_links=None,
-):
+    config: dict[str, Any],
+    init_model: Optional[str] = None,
+    restart_model: Optional[str] = None,
+    finetune_model: Optional[str] = None,
+    force_load: bool = False,
+    init_frz_model: Optional[str] = None,
+    shared_links: Optional[dict[str, Any]] = None,
+    finetune_links: Optional[dict[str, Any]] = None,
+) -> training.Trainer:
     multi_task = "model_dict" in config.get("model", {})
 
     # Initialize DDP
@@ -98,17 +99,22 @@ def get_trainer(
         fleet.init(is_collective=True)
 
     def prepare_trainer_input_single(
-        model_params_single, data_dict_single, rank=0, seed=None
-    ):
+        model_params_single: dict[str, Any],
+        data_dict_single: dict[str, Any],
+        rank: int = 0,
+        seed: Optional[int] = None,
+    ) -> tuple[DpLoaderSet, Optional[DpLoaderSet], Optional[DPPath]]:
         training_dataset_params = data_dict_single["training_data"]
         validation_dataset_params = data_dict_single.get("validation_data", None)
         validation_systems = (
             validation_dataset_params["systems"] if validation_dataset_params else None
         )
         training_systems = training_dataset_params["systems"]
-        training_systems = process_systems(training_systems)
+        trn_patterns = training_dataset_params.get("rglob_patterns", None)
+        training_systems = process_systems(training_systems, patterns=trn_patterns)
         if validation_systems is not None:
-            validation_systems = process_systems(validation_systems)
+            val_patterns = validation_dataset_params.get("rglob_patterns", None)
+            validation_systems = process_systems(validation_systems, val_patterns)
 
         # stat files
         stat_file_path_single = data_dict_single.get("stat_file", None)
@@ -342,6 +348,7 @@ def freeze(
     model: str,
     output: str = "frozen_model.json",
     head: Optional[str] = None,
+    do_atomic_virial: bool = False,
 ) -> None:
     paddle.set_flags(
         {
@@ -374,7 +381,7 @@ def freeze(
                 None,  # fparam
                 None,  # aparam
                 # InputSpec([], dtype="bool", name="do_atomic_virial"),  # do_atomic_virial
-                False,  # do_atomic_virial
+                do_atomic_virial,  # do_atomic_virial
             ],
             full_graph=True,
         )
@@ -396,7 +403,7 @@ def freeze(
                 None,  # fparam
                 None,  # aparam
                 # InputSpec([], dtype="bool", name="do_atomic_virial"),  # do_atomic_virial
-                False,  # do_atomic_virial
+                do_atomic_virial,  # do_atomic_virial
                 (
                     InputSpec([-1], "int64", name="send_list"),
                     InputSpec([-1], "int32", name="send_proc"),
@@ -409,6 +416,26 @@ def freeze(
             ],
             full_graph=True,
         )
+    for method_name in [
+        "get_buffer_rcut",
+        "get_buffer_type_map",
+        "get_buffer_dim_fparam",
+        "get_buffer_dim_aparam",
+        "get_buffer_intensive",
+        "get_buffer_sel_type",
+        "get_buffer_numb_dos",
+        "get_buffer_task_dim",
+    ]:
+        if hasattr(model, method_name):
+            setattr(
+                model,
+                method_name,
+                paddle.jit.to_static(
+                    getattr(model, method_name),
+                    input_spec=[],
+                    full_graph=True,
+                ),
+            )
     if output.endswith(".json"):
         output = output[:-5]
     paddle.jit.save(