mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/utils/__init__.py

@@ -14,12 +14,15 @@
 # ============================================================================
 """Utils module."""
 from __future__ import absolute_import
-from mindspore._c_expression import stress_detect, _reuse_data_ptr
-from .utils import ExitByRequest, _tft_handler
+from mindspore._c_expression import _reuse_data_ptr
+from .stress_detect import stress_detect
+from .utils import ExitByRequest, RSCPluginHandle, TFTCommValue, _tft_handler
 from .runtime_execution_order_check import runtime_execution_order_check, comm_exec_order_check
 from .sdc_detect import sdc_detect_start, sdc_detect_stop, get_sdc_detect_result
 from . import dryrun
+from .dlpack import from_dlpack, to_dlpack
 
 # Symbols from utils module.
 __all__ = ["stress_detect", "ExitByRequest", "runtime_execution_order_check", "dryrun", "_reuse_data_ptr",
-           "_tft_handler", "comm_exec_order_check", "sdc_detect_start", "sdc_detect_stop", "get_sdc_detect_result"]
+           "_tft_handler", "comm_exec_order_check", "sdc_detect_start", "sdc_detect_stop", "get_sdc_detect_result",
+           "RSCPluginHandle", "TFTCommValue", "from_dlpack", "to_dlpack"]

mindspore/utils/dlpack.py

@@ -0,0 +1,92 @@
+
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""dlpack for tensor."""
+from mindspore._c_expression import TensorPy as TensorPy_
+
+
+def from_dlpack(dlpack):
+    r"""
+    Converts a DLPack object to a MindSpore Tensor.
+
+    This function allows for the sharing of tensor data from other deep learning frameworks that support DLPack.
+    The data is not copied and the returned MindSpore Tensor shares the memory with the source tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        dlpack (PyCapsule): The DLPack object to be converted, which is a capsule containing a pointer to a
+            `DLManagedTensor`.
+
+    Returns:
+        Tensor, the MindSpore Tensor that shares memory with the DLPack object.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore.utils.dlpack import to_dlpack, from_dlpack
+        >>> import numpy as np
+        >>> # Create a MindSpore Tensor and convert it to DLPack
+        >>> x = ms.Tensor(np.random.rand(2, 3), ms.float32)
+        >>> dlpack_obj = to_dlpack(x)
+        >>>
+        >>> # Convert the DLPack object back to a MindSpore Tensor
+        >>> y = from_dlpack(dlpack_obj)
+        >>> print(x.shape == y.shape)
+        True
+    """
+    return TensorPy_.from_dlpack(dlpack)
+
+
+def to_dlpack(tensor):
+    r"""
+    Converts a MindSpore Tensor to a DLPack object.
+
+    The DLPack format is a standard for sharing tensor data between different deep learning frameworks.
+    The returned DLPack object is a Python capsule that can be consumed by other libraries that support DLPack.
+    The capsule contains a pointer to a `DLManagedTensor` structure. The consumer of the DLPack object is responsible
+    for releasing the memory.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        tensor (Tensor): The MindSpore Tensor to be converted.
+
+    Returns:
+        PyCapsule, a DLPack object that can be consumed by other libraries.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore.utils.dlpack import to_dlpack, from_dlpack
+        >>> import numpy as np
+        >>> # Convert a MindSpore Tensor to DLPack
+        >>> x = ms.Tensor(np.random.rand(2, 3), ms.float32)
+        >>> dlpack_obj = to_dlpack(x)
+        >>>
+        >>> # At this point, dlpack_obj can be used by other frameworks that support DLPack.
+        >>> # For demonstration, we convert it back to a MindSpore Tensor.
+        >>> y = from_dlpack(dlpack_obj)
+        >>> print(x.shape == y.shape)
+        True
+    """
+    if tensor.has_init:
+        tensor.init_data()
+    return TensorPy_.to_dlpack(tensor)

mindspore/utils/dryrun.py

@@ -74,7 +74,7 @@ def set_simulation():
     os.environ["MS_SIMULATION_LEVEL"] = "1"
     obj = TraceBack()
     Tensor.asnumpy = obj.inject(Tensor.asnumpy)
-    Tensor._getitem = obj.inject(Tensor._getitem)
+    Tensor.__getitem__ = obj.inject(Tensor.__getitem__)
     Tensor.is_contiguous = obj.inject(Tensor.is_contiguous)
     Tensor.flush_from_cache = obj.inject(Tensor.flush_from_cache)
     Tensor.__str__ = no_inject_traceback_for_print

mindspore/utils/runtime_execution_order_check.py

@@ -623,6 +623,16 @@ def runtime_execution_order_check(folders_, all_rank=None):
     parser = RankFolderParser(folders_)
     result_map = parser.parse()
 
+    if not result_map:
+        logger.error("No valid rank data found. Execution order check aborted.")
+        return
+
+    # Check for any rank with empty execution orders
+    for rank, orders in result_map.items():
+        if not orders:
+            logger.error(f"Rank {rank} has no valid execution orders. Please check the csv file.")
+            return
+
     # Modify execution orders
     modified_orders = modify_execute_orders(result_map)
 

mindspore/utils/sdc_detect.py

@@ -13,17 +13,15 @@
 # limitations under the License.
 # ============================================================================
 """SDC detect."""
-from mindspore import _c_expression
+import mindspore.tools
+from mindspore.common._decorator import deprecated
 
 
+@deprecated("2.7.1", "mindspore.tools.sdc_detect_start", module_prefix="mindspore.utils.")
 def sdc_detect_start():
     """
-    Start silent data corruption detection. It will check the inputs and outputs of MatMul operations during the
-    forward and backward computations on the current device, which may increase execution time. The overhead of the
-    check time decreases as the matrix shapes increase. Starting sdc detection results in approximately 100%
-    performance degradation for a single 4096-sized MatMul computation, and approximately 90% degradation on the
-    Llama2-7B model (model parallel is 4, pipeline parallel is 2, and using qkv concatenation and ffn concatenation in
-    decoder layers).
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.sdc_detect_start` instead.
 
     Supported Platforms:
         ``Ascend``
@@ -32,12 +30,14 @@ def sdc_detect_start():
         >>> from mindspore.utils import sdc_detect_start
         >>> sdc_detect_start()
     """
-    _c_expression.sdc_detect_start()
+    return mindspore.tools.sdc_detect_start()
 
 
+@deprecated("2.7.1", "mindspore.tools.sdc_detect_stop", module_prefix="mindspore.utils.")
 def sdc_detect_stop():
     """
-    Stop silent data corruption detection.
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.sdc_detect_stop` instead.
 
     Supported Platforms:
         ``Ascend``
@@ -46,12 +46,14 @@ def sdc_detect_stop():
         >>> from mindspore.utils import sdc_detect_stop
         >>> sdc_detect_stop()
     """
-    _c_expression.sdc_detect_stop()
+    return mindspore.tools.sdc_detect_stop()
 
 
+@deprecated("2.7.1", "mindspore.tools.get_sdc_detect_result", module_prefix="mindspore.utils.")
 def get_sdc_detect_result():
     """
-    Get the result of silent data corruption detection.
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.get_sdc_detect_result` instead.
 
     Returns:
         bool, indicating whether silent data corruption has occurred after detection start.
@@ -65,4 +67,4 @@ def get_sdc_detect_result():
         >>> print(result)
         False
     """
-    return _c_expression.get_sdc_detect_result()
+    return mindspore.tools.get_sdc_detect_result()

mindspore/utils/stress_detect.py

@@ -0,0 +1,43 @@
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Stress detect."""
+import mindspore.tools
+from mindspore.common._decorator import deprecated
+
+
+@deprecated("2.7.1", "mindspore.tools.stress_detect", module_prefix="mindspore.utils.")
+def stress_detect(detect_type="aic"):
+    """
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.stress_detect` instead.
+
+    Args:
+        detect_type (str, optional): The type of stress test to perform. There are two options available: ``'aic'`` and
+            ``'hccs'``, which perform AiCore and HCCS link stress tests on the device, respectively. Default: "aic".
+
+    Returns:
+        int, the return value represents the error type. 0 indicates normal. 1 indicates failure to start some or
+        all test cases. 2 indicates a hardware failure, and it is recommended to replace the device.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore.utils import stress_detect
+        >>> ret = stress_detect()
+        >>> print(ret)
+        0
+    """
+    return mindspore.tools.stress_detect(detect_type)

mindspore/utils/utils.py

@@ -16,6 +16,7 @@
 from __future__ import absolute_import
 
 import os
+import json
 from mindspore import log as logger
 from mindspore import context
 from mindspore import _checkparam as Validator
@@ -23,9 +24,9 @@ from mindspore.common import dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
-from mindspore.parallel._recovery_context import _set_recovery_context
 from mindspore.common.api import jit_class
 from mindspore._c_expression import _tft_start_record_threads, _tft_finish_record_threads
+from mindspore._c_expression import set_is_reboot_node, tft_register_config
 
 
 @jit_class
@@ -64,11 +65,149 @@ class ExitByRequest:
         return grad
 
 
+class TFTCommValue:
+    """Config values"""
+    ENABLE_MINDX = ['TTP:1', 'UCE:1', 'ARF:1', 'TSP:1', 'HCCE:1', 'RSC:1']  # support mindx to schedule
+    NEED_MINDIO = ["TTP:1", "UCE:1", "ARF:1", "TSP:1", "HCCE:1"]  # need mindio-ttp pkg
+    DISABLE_WATCHDOG = ['ARF:1', 'TSP:1', 'HCCE:1']  # close watchdog
+
+
+def _getenv():
+    """Get env """
+    tft_env = os.getenv("MS_ENABLE_TFT", "").strip()
+    thm_env = os.getenv("MS_ENABLE_THM", "").strip()
+    return tft_env, thm_env
+
+
+def _parser_tft_and_thm_env():
+    """Parser all config: tft, thm ..."""
+    tft_env, thm_env = _getenv()
+    tft_envs = tft_env.replace("{", "").replace("}", "").strip().split(",")
+    thm_envs = thm_env.replace("{", "").replace("}", "").strip().split(",")
+    all_config = {}
+    for item in tft_envs:
+        if item == "":
+            continue
+        key_v = item.split(":")
+        all_config[key_v[0].strip()] = key_v[1].strip()
+
+    for item in thm_envs:
+        if item == "":
+            continue
+        key_v = item.split(":")
+        if key_v[0] == "HCCL_STATUS_SAVE_CONFIG":
+            with open(key_v[1].strip("'\""), 'r', encoding='utf-8') as j:
+                json_values = json.load(j)
+                for key, val in json_values.items():
+                    if key == "HCCL_STATUS_SAVE_PATH" and not os.path.isabs(str(val)):
+                        logger.warning(
+                            f"HCCL_STATUS_SAVE_PATH should be absolute path, but get: {val}, Using default path:'/tmp'")
+                        val = "/tmp"
+                    key = "CCAE_" + key
+                    all_config[key] = val
+            continue
+        all_config[key_v[0].strip()] = key_v[1].strip()
+    if all_config.get("ARF") == "1":
+        logger.warning(f"Disable hccl_watchdog and turn on TTP when using ARF.")
+        all_config["HCCL_WATCHDOG"] = "0"
+        all_config["TTP"] = "1"
+    if all_config.get("HCCL_STATUS_SAVE") == "1":
+        os.environ["HCCL_STATUS_SAVE"] = "1"
+        os.environ["HCCL_STATUS_SAVE_PATH"] = all_config.get("CCAE_HCCL_STATUS_SAVE_PATH")
+        os.environ["HCCL_STATUS_SAVE_INTERVAL"] = str(all_config.get("CCAE_HCCL_STATUS_SAVE_INTERVAL"))
+    tft_register_config(all_config)
+
+
+class RSCPluginHandle:
+    """Third party controller handler"""
+
+    def __init__(self):
+        self.enable = False
+        self.tft_env, _ = _getenv()
+        self._check_env()
+        self.msmgr = None
+        self.init_taskd_agent = None
+        self.start_taskd_agent = None
+        self.register_func = None
+        self.using_agent = False
+
+    def _check_env(self):
+        """Check env"""
+        self.enable = any(v in self.tft_env for v in TFTCommValue.ENABLE_MINDX)
+
+    def check_enable(self):
+        """Check env"""
+        return self.enable
+
+    def _register_by_agent(self, func_map):
+        """ register by taskd agent"""
+        try:
+            from taskd.api.taskd_agent_api import init_taskd_agent, start_taskd_agent, register_func
+            self.init_taskd_agent = init_taskd_agent
+            self.start_taskd_agent = start_taskd_agent
+            self.register_func = register_func
+        except ImportError as e:
+            logger.warning(f"Import task agent: {str(e)}, try to using mindx plugin.")
+            return False
+        try:
+            logger.warning(f"register callbacks to taskd agent")
+            if not self.init_taskd_agent({"Framework": "MindSpore"}):
+                logger.warning(f"Init taskd agent failed, try to using mindx plugin.")
+                return False
+            for name, func in func_map.items():
+                self.register_func(name, func)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(f"Register callback func failed: {str(e)}, try to using mindx plugin.")
+            return False
+        self.using_agent = True
+        return True
+
+    def _register_by_plugin(self, func_map):
+        """ register by mindx msrun_plugin"""
+        # will delete in the future
+        self.using_agent = False
+        try:
+            from taskd.python.framework.agent.ms_mgr.msrun_plugin import MSRunPlugin
+            self.msmgr = MSRunPlugin()
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(f"Import mindx failed: {str(e)}, process controlled by msrun.")
+            return False
+        try:
+            for name, func in func_map.items():
+                self.msmgr.register_callbacks(name, func)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(f"Register callback func failed: {str(e)}, process controlled by msrun")
+            return False
+        return True
+
+    def register_callback(self, func_map: dict):
+        """Register function"""
+        if not isinstance(func_map, dict):
+            raise ValueError(f"The value of 'func_map' should be a dict, bug got:{func_map}.")
+        if self._register_by_agent(func_map):
+            return True
+        if self._register_by_plugin(func_map):
+            return True
+        return False
+
+    def start(self):
+        """Start execute taskd agent"""
+        if self.using_agent:
+            logger.warning(f"start by taskd agent")
+            self.start_taskd_agent()
+        else:
+            logger.warning(f"start by mindx")
+            if self.msmgr is None:
+                raise RuntimeError(f"Mindx unavailable, can not start training.")
+            self.msmgr.start()
+
+
 class TftHandle:
     """TftHandle class"""
 
     def __init__(self):
         super(TftHandle, self).__init__()
+        _parser_tft_and_thm_env()
         self._controller_ip = None
         self._controller_rank_id = None
         self._controller_port = None
@@ -124,14 +263,11 @@ class TftHandle:
         Args:
             **kwargs: Reserved parameters.
         """
-        tft_env = os.getenv("MS_ENABLE_TFT", "")
-        tft_opts = ["TTP:1", "UCE:1", "HCCE:1", "ARF:1", "TSP:1"]
-        tft_enabled = any([opt in tft_env for opt in tft_opts])
+        tft_env, _ = _getenv()
+        tft_enabled = any([opt in tft_env for opt in TFTCommValue.NEED_MINDIO])
         if not tft_enabled:
-            raise ValueError("MindIO TFT regitster need custom switch on[MS_ENABLE_TFT='{%s}']!" % ",".join(tft_opts))
+            raise ValueError(F"MindIO TFT register need custom switch on one of:{TFTCommValue.NEED_MINDIO}")
         if "ARF:1" in tft_env:
-            logger.warning(f"Disable hccl watchdog when using ARF.")
-            context.set_context(ascend_config={"hccl_watchdog": False})
             if "TTP:1" not in tft_env:
                 logger.warning(f"Turn on TTP config when using ARF.")
                 tft_env = tft_env.replace("{", "").replace("}", "")
@@ -181,7 +317,7 @@ class TftHandle:
         if self.tft.tft_is_reboot_node():
             logger.warning("tft report reboot init finish ")
             tft.tft_report_error(tft.ReportState.RS_INIT_FINISH.value)
-            _set_recovery_context(is_reboot_node=True)
+            set_is_reboot_node(True)
             ret = tft.tft_wait_next_action()
             if ret != tft.Action.RETRY.value:
                 raise RuntimeError(f"ARF init failed!")

mindspore/version.py

@@ -1 +1 @@
-__version__ = '2.7.0'
+__version__ = '2.7.1'

{mindspore-2.7.0.dist-info → mindspore-2.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mindspore
-Version: 2.7.0
+Version: 2.7.1
 Summary: MindSpore is a new open source deep learning training/inference framework that could be used for mobile, edge and cloud scenarios.
 Home-page: https://www.mindspore.cn
 Author: The MindSpore Authors
@@ -320,8 +320,9 @@ Project stable branches will be in one of the following states:
 
 ## Maintenance status
 
-| **Version**| **Status**  | **Initial Release Date**| **Next Phase**                        | **EOL Date**|
+| **Version**| **Status**   | **Initial Release Date** | **Next Phase**                         | **EOL Date**|
 |------------|--------------|--------------------------|----------------------------------------|-------------|
+| **r2.7**   | Maintained   | 2025-08-08               | Unmaintained <br> 2026-08-08 estimated | 2026-08-08  |
 | **r2.6**   | Maintained   | 2025-05-19               | Unmaintained <br> 2026-05-19 estimated | 2026-05-19  |
 | **r2.5**   | Maintained   | 2025-02-08               | Unmaintained <br> 2026-02-08 estimated | 2026-02-08  |
 | **r2.4**   | Maintained   | 2024-10-30               | Unmaintained <br> 2025-10-30 estimated | 2025-10-30  |