fix(tf2): apply model-level pair_exclude at nlist BUILD; align io test

Replace the bespoke test_pair_exclude_savedmodel.py with an aligned
IOTest subclass (TestDeepPotPairExclude) in test_io.py: it supplies only
the model dict and inherits test_data_equal / test_deep_eval, which export
through every backend and cross-compare at rtol/atol 1e-12 (with the built-in
all-NaN skip covering the numpy dpmodel force path). Gated on
DP_TEST_TF2_ONLY, the mode in which test_deep_eval exercises the jax2tf
'.savedmodel' path -- the TF v1 backend raises NotImplementedError on
pair_exclude_types, so it must not run there.

That aligned cross-backend eval exposed a real gap: the tf2 backend
('.savedmodeltf') silently ignored model-level pair_exclude_types (its
SavedModel returned the non-excluded energy 2.847 vs the correct 2.843).
tf2 was outside the original PR scope (dpmodel/pt_expt/jax) and its outer
TF wrapper (deepmd/tf2/make_model.py) never folded the exclusion into the
nlist. Fix it the same way as every other backend: thread pair_excl into
model_call_from_call_lower and apply the canonical dpmodel
apply_pair_exclusion_nlist at the nlist-BUILD seam (the tensors are already
ndtensorflow arrays, so no wrap/unwrap). All five backends now agree.

Author: Han Wang

deepmd/tf2/make_model.py

@@ -3,6 +3,7 @@
     Callable,
 )
 from typing import (
+    TYPE_CHECKING,
     Any,
 )
 
@@ -31,6 +32,11 @@
     normalize_coord,
 )
 
+if TYPE_CHECKING:
+    from deepmd.dpmodel.utils.exclude_mask import (
+        PairExcludeMask,
+    )
+
 
 def _unwrap_tuple(values: tuple[Array, ...]) -> tuple[tf.Tensor, ...]:
     return tuple(to_tf_tensor(value) for value in values)
@@ -56,9 +62,17 @@ def model_call_from_call_lower(
     fparam: Array | None,
     aparam: Array | None,
     do_atomic_virial: bool = False,
+    pair_excl: "PairExcludeMask | None" = None,
 ) -> dict[str, Array]:
     """Return model prediction from lower interface.
 
+    ``pair_excl`` is the model-level pair-type exclusion mask. Exclusion is a
+    nlist-BUILD transform (decision #18/A4): it is folded into the neighbor
+    list here, where the list is built, by the canonical dpmodel
+    ``apply_pair_exclusion_nlist`` (the tensors are already ``ndtensorflow``
+    arrays), because the lower model consumes a pre-excluded nlist and never
+    re-applies it.
+
     Parameters
     ----------
     coord
@@ -126,6 +140,15 @@ def no_pbc() -> tuple[Array, Array, Array]:
         # so it doesn't need to be distinguished here
         distinguish_types=False,
     )
+    if pair_excl is not None:
+        # Reuse the canonical dpmodel nlist-BUILD transform (decision #18/A4):
+        # ``nlist``/``extended_atype`` are already ndtensorflow arrays, so no
+        # wrap/unwrap is needed. Identity when there is nothing to exclude.
+        from deepmd.dpmodel.utils.nlist import (
+            apply_pair_exclusion_nlist,
+        )
+
+        nlist = apply_pair_exclusion_nlist(nlist, extended_atype, pair_excl)
     extended_coord = xp.reshape(extended_coord, (nframes, -1, 3))
     model_predict_lower = wrap_value(
         call_lower(

deepmd/tf2/utils/serialization.py

@@ -377,6 +377,9 @@ def call(
                     fparam=fparam,
                     aparam=aparam,
                     do_atomic_virial=do_atomic_virial,
+                    # exclusion is a nlist-BUILD transform (decision #18/A4);
+                    # the traced lower consumes a pre-excluded nlist.
+                    pair_excl=getattr(model.atomic_model, "pair_excl", None),
                 )
             )
 

source/tests/consistent/io/test_io.py

@@ -311,3 +311,59 @@ def setUp(self) -> None:
 
     def tearDown(self) -> None:
         IOTest.tearDown(self)
+
+
+@unittest.skipIf(
+    not DP_TEST_TF2_ONLY,
+    "pair_exclude_types is not supported by the TF v1 backend; it is validated "
+    "in the TF2-only job, where test_deep_eval also exercises the jax2tf "
+    "'.savedmodel' export path (see the backend table in test_deep_eval).",
+)
+class TestDeepPotPairExclude(unittest.TestCase, IOTest):
+    """Model-level ``pair_exclude_types`` is a nlist-BUILD transform (decision
+    #18/A4). Every backend folds it in where the neighbor list is built (the
+    jax2tf ``.savedmodel`` export reuses the dpmodel
+    ``apply_pair_exclusion_nlist`` via the ``ndtensorflow`` namespace), so the
+    exported models must still eval-agree across backends.
+    """
+
+    def setUp(self) -> None:
+        model_def_script = {
+            "type_map": ["O", "H"],
+            "pair_exclude_types": [[0, 1]],
+            "descriptor": {
+                "type": "se_e2_a",
+                "sel": [20, 20],
+                "rcut_smth": 0.50,
+                "rcut": 6.00,
+                "neuron": [
+                    3,
+                    6,
+                ],
+                "resnet_dt": False,
+                "axis_neuron": 2,
+                "precision": "float64",
+                "type_one_side": True,
+                "seed": 1,
+            },
+            "fitting_net": {
+                "type": "ener",
+                "neuron": [
+                    5,
+                    5,
+                ],
+                "resnet_dt": True,
+                "precision": "float64",
+                "atom_ener": [],
+                "seed": 1,
+            },
+        }
+        model = get_model(copy.deepcopy(model_def_script))
+        self.data = {
+            "model": model.serialize(),
+            "backend": "test",
+            "model_def_script": model_def_script,
+        }
+
+    def tearDown(self) -> None:
+        IOTest.tearDown(self)