refactor(deepeval): implement backend serialize via model.serialize

Switch DeepEval.serialize() to delegate to DeepEvalBackend.serialize(), and implement serialize() in each backend by calling the underlying model's serialize().

Also move Node import in dp show to module top-level.

Authored by OpenClaw (model: gpt-5.2)

Author: njzjz-bot

deepmd/dpmodel/infer/deep_eval.py

@@ -406,6 +406,18 @@ def get_model_def_script(self) -> dict:
         """Get model definition script."""
         return json.loads(self.dp.get_model_def_script())
 
+    def serialize(self) -> dict[str, Any]:
+        model = self.dp
+        data: dict[str, Any] = {
+            "backend": "DPModel",
+            "model": model.serialize(),
+            "model_def_script": self.get_model_def_script(),
+            "@variables": {},
+        }
+        if model.get_min_nbor_dist() is not None:
+            data["@variables"]["min_nbor_dist"] = model.get_min_nbor_dist()
+        return data
+
     def get_observed_types(self) -> dict:
         """Get observed types (elements) of the model during data statistics.
 

deepmd/entrypoints/show.py

@@ -4,6 +4,9 @@
     Any,
 )
 
+from deepmd.dpmodel.utils.serialization import (
+    Node,
+)
 from deepmd.infer.deep_eval import (
     DeepEval,
 )
@@ -138,10 +141,6 @@ def show(
             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'.")

deepmd/infer/deep_eval.py

@@ -361,6 +361,16 @@ def get_model(self) -> Any:
             The model module implemented by the deep learning framework.
         """
 
+    @abstractmethod
+    def serialize(self) -> dict[str, Any]:
+        """Serialize the loaded model to a backend-unified dictionary.
+
+        Returns
+        -------
+        dict
+            Serialized model data. Must include key ``"model"``.
+        """
+
 
 class DeepEval(ABC):
     """High-level Deep Evaluator interface.
@@ -422,43 +432,8 @@ 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)
+        """Serialize the loaded model to a backend-unified dictionary."""
+        return self.deep_eval.serialize()
 
     def get_rcut(self) -> float:
         """Get the cutoff radius of this model."""

deepmd/jax/infer/deep_eval.py

@@ -47,6 +47,9 @@
 from deepmd.jax.common import (
     to_jax_array,
 )
+from deepmd.jax.env import (
+    jax,
+)
 from deepmd.jax.model.hlo import (
     HLO,
 )
@@ -187,6 +190,19 @@ def get_ntypes_spin(self) -> int:
         """Get the number of spin atom types of this model."""
         return 0
 
+    def serialize(self) -> dict[str, Any]:
+        model = self.dp
+        data: dict[str, Any] = {
+            "backend": "JAX",
+            "jax_version": jax.__version__,
+            "model": model.serialize(),
+            "model_def_script": json.loads(model.get_model_def_script()),
+            "@variables": {},
+        }
+        if model.get_min_nbor_dist() is not None:
+            data["@variables"]["min_nbor_dist"] = model.get_min_nbor_dist()
+        return data
+
     def eval(
         self,
         coords: np.ndarray,

deepmd/pd/infer/deep_eval.py

@@ -730,6 +730,18 @@ def get_model_def_script(self) -> dict:
         """Get model definition script."""
         return self.model_def_script
 
+    def serialize(self) -> dict[str, Any]:
+        model = self.dp.model["Default"]
+        data: dict[str, Any] = {
+            "backend": "Paddle",
+            "model": model.serialize(),
+            "model_def_script": self.get_model_def_script(),
+            "@variables": {},
+        }
+        if model.get_min_nbor_dist() is not None:
+            data["@variables"]["min_nbor_dist"] = model.get_min_nbor_dist()
+        return data
+
     def get_model_size(self) -> dict:
         """Get model parameter count.
 

deepmd/pretrained/deep_eval.py

@@ -184,3 +184,6 @@ def get_ntypes_spin(self) -> int:
 
     def get_model(self) -> Any:
         return self._backend.get_model()
+
+    def serialize(self) -> dict[str, Any]:
+        return self._backend.serialize()

deepmd/pt/infer/deep_eval.py

@@ -702,6 +702,18 @@ def get_model_def_script(self) -> dict:
         """Get model definition script."""
         return self.model_def_script
 
+    def serialize(self) -> dict[str, Any]:
+        model = self.dp.model["Default"]
+        data: dict[str, Any] = {
+            "backend": "PyTorch",
+            "model": model.serialize(),
+            "model_def_script": self.get_model_def_script(),
+            "@variables": {},
+        }
+        if model.get_min_nbor_dist() is not None:
+            data["@variables"]["min_nbor_dist"] = model.get_min_nbor_dist()
+        return data
+
     def get_model_size(self) -> dict:
         """Get model parameter count.
 

deepmd/pt_expt/infer/deep_eval.py

@@ -665,6 +665,13 @@ def get_model_def_script(self) -> dict:
         """Get model definition script."""
         return self.metadata
 
+    def serialize(self) -> dict[str, Any]:
+        from deepmd.pt_expt.utils.serialization import (
+            serialize_from_file,
+        )
+
+        return serialize_from_file(self.model_path)
+
     def get_model(self) -> torch.nn.Module:
         """Get the exported model module.
 

deepmd/tf/infer/deep_eval.py

@@ -110,6 +110,7 @@ def __init__(
             input_map=input_map,
         )
         self.load_prefix = load_prefix
+        self.model_file = model_file
 
         # graph_compatable should be called after graph and prefix are set
         if not self._graph_compatable():
@@ -1121,6 +1122,38 @@ def get_model_def_script(self) -> dict:
         model_def_script = script.decode("utf-8")
         return json.loads(model_def_script)["model"]
 
+    def serialize(self) -> dict[str, Any]:
+        from deepmd.tf.model.model import (
+            Model,
+        )
+        from deepmd.tf.utils.graph import (
+            load_graph_def,
+        )
+
+        graph, graph_def = load_graph_def(str(self.model_file))
+
+        model_def_script = self.get_model_def_script()
+        model = Model(**model_def_script)
+        # important! must be called before serialize
+        model.init_variables(graph=graph, graph_def=graph_def)
+        model_dict = model.serialize()
+
+        data: dict[str, Any] = {
+            "backend": "TensorFlow",
+            "tf_version": tf.__version__,
+            "model": model_dict,
+            "model_def_script": model_def_script,
+        }
+        try:
+            t_min_nbor_dist = self._get_tensor("train_attr/min_nbor_dist:0")
+        except KeyError:
+            pass
+        else:
+            [min_nbor_dist] = run_sess(self.sess, [t_min_nbor_dist], feed_dict={})
+            data.setdefault("@variables", {})
+            data["@variables"]["min_nbor_dist"] = float(min_nbor_dist)
+        return data
+
     def get_model(self) -> "tf.Graph":
         """Get the TensorFlow graph.
 
@@ -1172,6 +1205,7 @@ def __init__(
             input_map=input_map,
         )
         self.load_prefix = load_prefix
+        self.model_file = model_file
 
         # graph_compatable should be called after graph and prefix are set
         if not self._graph_compatable():