Merge master into feat-graph-dpa2 (integrate deepmodeling#5758 dpa1 graph CUDA rework)

Master's deepmodeling#5758 restructured the NeighborGraph deployment ABI while this
PR's review batch was landing; this merge re-expresses the batch on the
new schema. Master's conventions adopted as the base:

- 13-input graph lower (atype, n_node, n_local, edge_index, edge_vec,
  edge_mask, destination_order, destination_row_ptr, source_order,
  source_row_ptr, fparam, aparam, charge_spin), canonicalize=True
  destination-major payloads, destination_sorted validation, and the
  canonical (compressed-dpa1 CUDA) export flavor.
- n_local as a first-class device input on every graph route: this
  SUBSUMES this branch's 17th-input with-comm design -- the extra input
  is dropped, while the all-8-comm-tensors-on-CPU placement, the
  border_op explicit CUDA-stream sync, and the ago==0 preflight cache
  are kept.
- n_local now also masks halo rows of the per-node outputs (owned rows
  unchanged); contract tests updated.
- The rectangular-aparam ragged extension shim (_extend_graph_aparam)
  is kept as a correct alternate input layout; flat (N, nda) remains
  the canonical trace/export ABI.

Review-batch semantics re-grafted onto the new base:

- trace capacity from the real synthetic edge count (probe + prime
  collision-free dims, export and compiled training).
- flat (N, nda) aparam ABI: trace sample slot 11, dynamic-shape spec
  sharing atype's n_node_total symbol, all rectangular->flat boundaries.
- energy gate on the default-flip, now in the shared
  graph_lower.model_uses_graph_lower; dense compiled key translation
  stays output-agnostic.
- with-comm graph artifact: trace branch re-added to the export graph
  section (master had none), nested-artifact trace now inherits
  lower_kind, EnergyModel with-comm wrapper rewritten to the 13-input
  base, C++ run_model_graph_with_comm and its call site moved to the
  13-input pack (canonicalized payload + flat aparam via
  extend_graph_aparam).
- pt_expt dpa1 call_graph regains the comm_dict pass-through (ABI
  stability; forwarded to the dpmodel fallback).

Verified: graph export/metadata/with-comm suites, dpa1+dpa2 graph
lower, dpmodel graph suites, training+multitask, dos_graph,
neighbor_list, graph deepeval, dpa1 descriptor (400+ tests); C++
full rebuild + dpa1/dpa2 graph and fparam/aparam gtests (39 pass)
on regenerated 13-input fixtures.

Author: Han Wang

.github/workflows/mirror_gitee.yml

@@ -1,22 +1,38 @@
 name: Mirror to Gitee Repo
 
+# Ref creation is also delivered as a push event, but deletion may only emit a
+# delete event. Keep both triggers so removed branches and tags are pruned from
+# the mirror without launching duplicate mirrors for ref creation.
 on:
   push:
-    branches-ignore:
-      - "copilot/**"
-      - "dependabot/**"
-      - "pre-commit-ci-update-config"
+    # Use positive patterns with exclusions so tag pushes can be listed below.
+    # `branches-ignore` by itself disables all tag-triggered runs.
+    branches:
+      - "**"
+      # GitHub creates these ephemeral refs while testing a merge queue entry.
+      # They are neither source branches nor refs that Gitee should receive.
+      - "!gh-readonly-queue/**"
+      - "!copilot/**"
+      - "!dependabot/**"
+      - "!pre-commit-ci-update-config"
+    tags:
+      - "**"
   delete:
-  create:
 
 # Ensures that only one mirror task will run at a time.
 concurrency:
   group: git-mirror
 
 jobs:
   git-mirror:
-    if: github.repository_owner == 'deepmodeling'
-    runs-on: ubuntu-slim
+    # Delete events use the default branch as `github.ref`, so inspect the
+    # payload ref to suppress only ephemeral merge-queue branch deletions.
+    if: >-
+      github.repository_owner == 'deepmodeling' &&
+      (github.event_name != 'delete' ||
+       !startsWith(github.event.ref, 'gh-readonly-queue/'))
+    # This is a Docker action; ubuntu-slim does not provide a Docker daemon.
+    runs-on: ubuntu-latest
     steps:
       - uses: wearerequired/git-mirror-action@v1
         env:

backend/dynamic_metadata.py

@@ -1,8 +1,16 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
+"""Provide project metadata that depends on the selected build configuration."""
+
 import sys
+from collections.abc import (
+    Mapping,
+)
 from pathlib import (
     Path,
 )
+from typing import (
+    Any,
+)
 
 from .find_pytorch import (
     get_pt_requirement,
@@ -27,29 +35,44 @@ def __dir__() -> list[str]:
 
 
 def dynamic_metadata(
-    field: str,
-    settings: dict[str, object] | None = None,
-):
-    assert field in ["optional-dependencies", "entry-points", "scripts"]
+    settings: Mapping[str, object],
+    _project: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Return one metadata fragment using the standard v1 provider protocol.
+
+    Each ``[[tool.dynamic-metadata]]`` entry selects a field explicitly. The
+    returned mapping is merged into the resolved ``[project]`` table by
+    scikit-build-core.
+    """
+    field = settings.get("field")
+    if not isinstance(field, str) or field not in {
+        "optional-dependencies",
+        "scripts",
+    }:
+        msg = f"Unsupported dynamic metadata field: {field!r}"
+        raise ValueError(msg)
+
     _, _, find_libpython_requires, extra_scripts, tf_version, pt_version = (
         get_argument_from_env()
     )
     with Path("pyproject.toml").open("rb") as f:
         pyproject = tomllib.load(f)
 
     if field == "scripts":
-        return {
+        result = {
             **pyproject["tool"]["deepmd_build_backend"]["scripts"],
             **extra_scripts,
         }
-    elif field == "optional-dependencies":
+    else:
         optional_dependencies = pyproject["tool"]["deepmd_build_backend"][
             "optional-dependencies"
         ]
         optional_dependencies["lmp"].extend(find_libpython_requires)
         optional_dependencies["ipi"].extend(find_libpython_requires)
-        return {
+        result = {
             **optional_dependencies,
             **get_tf_requirement(tf_version),
             **get_pt_requirement(pt_version),
         }
+
+    return {field: result}

backend/read_env.py

@@ -135,5 +135,6 @@ def get_argument_from_env() -> tuple[str, list, list, dict, str, str]:
 def set_scikit_build_env() -> None:
     """Set scikit-build environment variables before executing scikit-build."""
     cmake_minimum_required_version, cmake_args, _, _, _, _ = get_argument_from_env()
-    os.environ["SKBUILD_CMAKE_MINIMUM_VERSION"] = cmake_minimum_required_version
+    # scikit-build-core v1 expects cmake.version to be a version specifier.
+    os.environ["SKBUILD_CMAKE_VERSION"] = f">={cmake_minimum_required_version}"
     os.environ["SKBUILD_CMAKE_ARGS"] = ";".join(cmake_args)

deepmd/dpmodel/atomic_model/base_atomic_model.py

@@ -320,6 +320,51 @@ def forward_common_atomic(
         atom_mask = xp_take_first_n(ext_atom_mask, 1, nloc)
         return self._finalize_atomic_ret(ret_dict, atom_mask, atype)
 
+    def _prepare_graph_nodes(
+        self,
+        n_node: Array,
+        n_local: Array | None,
+        atype: Array,
+        reference: Array,
+    ) -> tuple[Array, Array]:
+        """Apply node masks shared by generic and compact graph forwards."""
+        xp = array_api_compat.array_namespace(reference)
+        atype = xp.asarray(atype, device=array_api_compat.device(reference))
+        atom_mask = self.make_atom_mask(atype)
+        atype_clamped = xp.where(atom_mask, atype, xp.zeros_like(atype))
+        output_mask = atom_mask
+        if n_local is not None:
+            from deepmd.dpmodel.utils.neighbor_graph import (
+                node_ownership_mask,
+            )
+
+            output_mask = output_mask & node_ownership_mask(
+                n_node,
+                n_local,
+                atype.shape[0],
+            )
+        if self.atom_excl is not None:
+            output_mask = xp.logical_and(
+                output_mask,
+                self.atom_excl.build_type_exclude_mask(atype_clamped),
+            )
+        return atype_clamped, output_mask
+
+    def _prepare_graph_inputs(
+        self,
+        graph: "NeighborGraph",
+        atype: Array,
+    ) -> tuple["NeighborGraph", Array, Array]:
+        """Apply graph masks shared by standard and fused atomic forwards."""
+        atype_clamped, output_mask = self._prepare_graph_nodes(
+            graph.n_node,
+            graph.n_local,
+            atype,
+            graph.edge_vec,
+        )
+        self._assert_graph_pair_excluded(graph, atype_clamped)
+        return graph, atype_clamped, output_mask
+
     def forward_common_atomic_graph(
         self,
         graph: "NeighborGraph",
@@ -365,17 +410,7 @@ def forward_common_atomic_graph(
             the result dict on the flat node axis, defined by the `FittingOutputDef`.
 
         """
-        xp = array_api_compat.array_namespace(graph.edge_vec)
-        atype = xp.asarray(atype, device=array_api_compat.device(graph.edge_vec))
-        atom_mask = self.make_atom_mask(atype)  # (N,) bool
-        atype_clamped = xp.where(atom_mask, atype, xp.zeros_like(atype))
-        # NOTE: model-level ``pair_exclude_types`` is NOT applied here. It is a
-        # graph-BUILD transform (decision #18) already folded into
-        # ``graph.edge_mask`` by the NeighborGraph builder (Python) or
-        # ``applyPairExclusion`` (C++); this method consumes a pre-excluded graph.
-        # Fail-safe (eager only): guard against a caller that skipped the build
-        # seam, which would silently INCLUDE excluded pairs (fail-open).
-        self._assert_graph_pair_excluded(graph, atype_clamped)
+        graph, atype_clamped, output_mask = self._prepare_graph_inputs(graph, atype)
         ret_dict = self.forward_atomic_graph(
             graph,
             atype_clamped,
@@ -384,7 +419,7 @@ def forward_common_atomic_graph(
             charge_spin=charge_spin,
             comm_dict=comm_dict,
         )
-        return self._finalize_atomic_ret(ret_dict, atom_mask, atype)
+        return self._finalize_atomic_ret(ret_dict, output_mask, atype)
 
     def _assert_nlist_pair_excluded(self, nlist: Array, extended_atype: Array) -> None:
         """Fail-safe: assert the nlist reaching the dense seam is pre-excluded.
@@ -498,10 +533,16 @@ def _finalize_atomic_ret(
 
         """
         xp = array_api_compat.array_namespace(atype)
-        ret_dict = self.apply_out_stat(ret_dict, atype)
+        safe_atype = xp.where(
+            self.make_atom_mask(atype),
+            atype,
+            xp.zeros_like(atype),
+        )
+        ret_dict = self.apply_out_stat(ret_dict, safe_atype)
         if self.atom_excl is not None:
             atom_mask = xp.logical_and(
-                atom_mask, self.atom_excl.build_type_exclude_mask(atype)
+                atom_mask,
+                self.atom_excl.build_type_exclude_mask(safe_atype),
             )
         lead = atom_mask.shape  # (nf, nloc) dense | (N,) graph
         for kk in ret_dict.keys():

deepmd/dpmodel/atomic_model/dp_atomic_model.py

@@ -37,6 +37,46 @@
 )
 
 
+def _extend_graph_aparam(
+    aparam: Array,
+    n_node: Array,
+    n_local: Array,
+    n_total: int,
+) -> Array:
+    """Expand frame-local atomic parameters onto a local-plus-halo node axis."""
+    import array_api_compat
+
+    from deepmd.dpmodel.utils.neighbor_graph import (
+        frame_id_from_n_node,
+        node_ownership_mask,
+    )
+
+    xp = array_api_compat.array_namespace(aparam, n_node, n_local)
+    frame_id = frame_id_from_n_node(n_node, n_total=n_total)
+    frame_end = xp.cumulative_sum(n_node)
+    frame_start = frame_end - n_node
+    node_index = xp.arange(
+        n_total,
+        dtype=n_node.dtype,
+        device=array_api_compat.device(n_node),
+    )
+    index_in_frame = node_index - xp.take(frame_start, frame_id, axis=0)
+    local_capacity = aparam.shape[1]
+    sentinel = xp.zeros(
+        (aparam.shape[0], 1, aparam.shape[2]),
+        dtype=aparam.dtype,
+        device=array_api_compat.device(aparam),
+    )
+    padded_aparam = xp.concat([aparam, sentinel], axis=1)
+    padded_capacity = local_capacity + 1
+    local_index = index_in_frame % padded_capacity
+    flat_index = frame_id * padded_capacity + local_index
+    flat_aparam = xp.reshape(padded_aparam, (-1, aparam.shape[-1]))
+    gathered = xp.take(flat_aparam, flat_index, axis=0)
+    ownership = node_ownership_mask(n_node, n_local, n_total)
+    return xp.where(ownership[:, None], gathered, xp.zeros_like(gathered))
+
+
 @BaseAtomicModel.register("standard")
 class DPAtomicModel(BaseAtomicModel):
     r"""Model give atomic prediction of some physical property.
@@ -315,8 +355,22 @@ def forward_atomic_graph(
             # compiled-training paths when ``numb_fparam > 0``.
             frame_id = frame_id_from_n_node(graph.n_node, n_total=atype.shape[0])
             fparam_node = xp.take(fparam, frame_id, axis=0)  # (N, ndf)
+        aparam_node = aparam
+        if aparam is not None and graph.n_local is not None and aparam.ndim == 3:
+            aparam_node = _extend_graph_aparam(
+                aparam,
+                graph.n_node,
+                graph.n_local,
+                atype.shape[0],
+            )
         return self.fitting_net.call_graph(
-            gg, atype, gr=rot_mat, g2=None, h2=None, fparam=fparam_node, aparam=aparam
+            gg,
+            atype,
+            gr=rot_mat,
+            g2=None,
+            h2=None,
+            fparam=fparam_node,
+            aparam=aparam_node,
         )
 
     def compute_or_load_stat(

deepmd/dpmodel/common.py

@@ -85,7 +85,12 @@ def get_xp_precision(
     elif precision == "global":
         return get_xp_precision(xp, RESERVED_PRECISION_DICT[GLOBAL_NP_FLOAT_PRECISION])
     elif precision == "bfloat16":
-        return ml_dtypes.bfloat16
+        # Return the backend-native bfloat16 dtype when available (e.g. torch.bfloat16),
+        # falling back to ml_dtypes.bfloat16 for NumPy/JAX-compatible namespaces that
+        # do not expose a native bfloat16.  This fixes Code scan #5638: PyTorch tensors
+        # cannot be cast to ml_dtypes.bfloat16 via xp.astype(), but can be cast to the
+        # namespace's own bfloat16.
+        return getattr(xp, "bfloat16", ml_dtypes.bfloat16)
     else:
         raise ValueError(f"unsupported precision {precision} for {xp}")
 

deepmd/dpmodel/descriptor/dpa1.py

@@ -434,12 +434,13 @@ def uses_graph_lower(self) -> bool:
         """Returns whether this descriptor supports the graph-native lower.
 
         The graph-native lower (``call_graph``) covers the factorizable path
-        AND transformer attention (``attn_layer >= 0``, NeighborGraph PR-D)
-        with concat OR strip type-embedding.  ``exclude_types`` is fully
-        supported via
+        and transformer attention (``attn_layer >= 0``) with concat or strip
+        type embedding. ``exclude_types`` is applied through
         :func:`~deepmd.dpmodel.utils.neighbor_graph.apply_pair_exclusion`.
-        Compressed descriptors are the remaining ineligible config and fall
-        back to the legacy dense path, so those models keep working unchanged.
+        Geo-compressed strip models
+        (``geo_compress=True``, ``attn_layer == 0``) are also graph-eligible;
+        tebd-only compression and compressed descriptors with descriptor-level
+        exclusions stay on the legacy dense path.
 
         Eligibility does NOT imply numerical interchangeability with the
         dense route for every config: with ``smooth_type_embedding=True``
@@ -449,13 +450,13 @@ def uses_graph_lower(self) -> bool:
         """
         if self._graph_lower_disabled:
             return False
-        # compressed descriptors have no graph kernel (geo/tebd tabulation is
-        # dense-only); keep them on the legacy dense path.
         if self.compress:
-            return False
-        # strip is graph-eligible (per-edge factorized embedding, no neighbor
-        # coupling); exclude_types is graph-native via ``apply_pair_exclusion``
-        # (owned at this seam). Only compression / the disable flag force dense.
+            return (
+                self.geo_compress
+                and self.se_atten.tebd_input_mode == "strip"
+                and self.se_atten.attn_layer == 0
+                and not self.se_atten.exclude_types
+            )
         return self.se_atten.tebd_input_mode in ("concat", "strip")
 
     def disable_graph_lower(self) -> None:
@@ -1782,7 +1783,7 @@ def call_graph(
         Notes
         -----
         Known limitations:
-        - ``tebd_input_mode`` in {"concat", "strip"}; compressed descriptors stay dense;
+        - ``tebd_input_mode`` in {"concat", "strip"};
         - ``exclude_types`` is applied graph-natively via ``apply_pair_exclusion``.
         """
         from deepmd.dpmodel.utils.neighbor_graph import (