feat(show): add serialization-tree via DeepEval.serialize

deepmd/entrypoints/show.py

@@ -136,3 +136,14 @@ def show(
                 observed_types = model.get_observed_types()
             log.info(f"Number of observed types: {observed_types['type_num']} ")
             log.info(f"Observed types: {observed_types['observed_type']} ")
+
+    if "serialization-tree" in ATTRIBUTES:
+        from deepmd.dpmodel.utils.serialization import (
+            Node,
+        )
+
+        data = model.serialize()
+        if "model" not in data:
+            raise RuntimeError("Serialized model data does not contain key 'model'.")
+        root = Node.deserialize(data["model"])
+        log.info("Model serialization tree:\n" + str(root))

deepmd/infer/deep_eval.py

@@ -404,6 +404,7 @@
         neighbor_list: Optional["ase.neighborlist.NewPrimitiveNeighborList"] = None,
         **kwargs: Any,
     ) -> None:
+        self.model_file = model_file
         self.deep_eval = DeepEvalBackend(
             model_file,
             self.output_def,
@@ -420,6 +421,45 @@
     def output_def(self) -> ModelOutputDef:
         """Returns the output variable definitions."""
 
+    def serialize(self) -> dict[str, Any]:
+        """Serialize the model file to a dictionary (backend-unified).
+
+        This is a convenience wrapper around backend-specific serialization
+        hooks, intended for unified model inspection / display.
+
+        Returns
+        -------
+        dict
+            Serialized model data (must include key ``"model"``).
+
+        Raises
+        ------
+        NotImplementedError
+            If the detected backend does not support IO serialization.
+        """
+        backend_cls = Backend.detect_backend_by_model(self.model_file)
+
+        # internal alias backend: resolve to a verified local file first
+        if getattr(backend_cls, "name", "").lower() == "pretrained":
+            from deepmd.pretrained.deep_eval import (
+                parse_pretrained_alias,
+            )
+            from deepmd.pretrained.download import (
+                resolve_model_path,
+            )
+
+            model_name = parse_pretrained_alias(self.model_file)
+            resolved = str(resolve_model_path(model_name))
+            backend_cls = Backend.detect_backend_by_model(resolved)
+            return backend_cls().serialize_hook(resolved)
+
+        if not (backend_cls.features & Backend.Feature.IO):
+            raise NotImplementedError(
+                f"Backend '{backend_cls.name}' does not support serialization."
+            )
+
+        return backend_cls().serialize_hook(self.model_file)
+
     def get_rcut(self) -> float:
         """Get the cutoff radius of this model."""
         return self.deep_eval.get_rcut()

deepmd/main.py

@@ -942,6 +942,7 @@ def main_parser() -> argparse.ArgumentParser:
             "fitting-net",
             "size",
             "observed-type",
+            "serialization-tree",
         ],
         nargs="+",
     )