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

mindspore/train/callback/_checkpoint.py

@@ -628,6 +628,13 @@ class ModelCheckpoint(Callback):
         if "step_num" in self._append_dict:
             self._append_dict["step_num"] = self._append_step_num + step_num
 
+    def _update_save_step(self, cb_params):
+        """update step if used async d2h copy"""
+        step_num_in_epoch = int((cb_params.cur_step_num - 1) % cb_params.batch_num + 1)
+        if self._d2h_async and self._run_mode == context.GRAPH_MODE:
+            step_num_in_epoch -= 1
+        return step_num_in_epoch
+
     def _save_ckpt(self, cb_params, force_to_save=False):
         """Save checkpoint files."""
         if cb_params.cur_step_num == self._last_triggered_step:
@@ -638,7 +645,7 @@ class ModelCheckpoint(Callback):
             self._flush_from_cache(cb_params)
 
         save_ckpt = self._check_save_ckpt(cb_params, force_to_save)
-        step_num_in_epoch = int((cb_params.cur_step_num - 1) % cb_params.batch_num + 1)
+        step_num_in_epoch = self._update_save_step(cb_params)
 
         if save_ckpt:
 

mindspore/train/callback/_flops_collector.py

@@ -31,6 +31,7 @@ from mindspore.communication.management import (create_group, get_group_size,
 from mindspore.parallel._auto_parallel_context import auto_parallel_context
 from mindspore.ops import operations as P
 from mindspore.common import Tensor
+from mindspore import context
 import mindspore.nn as nn
 
 
@@ -151,21 +152,16 @@ class FlopsUtilizationCollector(Callback):
         """
         Check whether FlopsUtilizationCollector is working in the current environment
         """
+        if context.get_context("mode") != context.GRAPH_MODE:
+            if self.verbose:
+                raise ValueError("FlopsUtilizationCollector now only support graph mode.")
+            logger.info("FlopsUtilizationCollector now only support graph mode.")
+            return False
         cb_params = run_context.original_args()
         if cb_params.mode == 'train':
             network = cb_params.train_network
-            if not network.compiled:
-                if self.verbose:
-                    raise ValueError("FlopsUtilizationCollector now only support graph mode.")
-                logger.info("FlopsUtilizationCollector now only support graph mode.")
-                return False
         elif cb_params.mode == 'eval':
             network = cb_params.eval_network
-            if not network.compiled:
-                if self.verbose:
-                    raise ValueError("FlopsUtilizationCollector now only support graph mode.")
-                logger.info("FlopsUtilizationCollector now only support graph mode.")
-                return False
         else:
             if self.verbose:
                 raise ValueError('FlopsUtilizationCollector only support train and eval mode!')

mindspore/train/callback/_train_fault_tolerance.py

@@ -167,6 +167,7 @@ def _tft_stop_callback(args, cb_ctx):
     """ Callback used for TFT stop function."""
     logger.warning(f"Enter _tft_stop_callback device_id: {cb_ctx.device_id}")
     _stop_device(cb_ctx.device_id)
+    cb_ctx.stop_been_called = True
     if (not cb_ctx.is_uce_rank) and (not cb_ctx._is_params_consistent()):  # pylint: disable=W0212
         raise RuntimeError("Can't stop device, because training parameters are left in inconsistent state!")
     cb_ctx.is_uce_rank = False
@@ -191,7 +192,7 @@ def _tft_rebuild_sub_groups(fault_ranks, args, ctx):
 class TrainFaultTolerance(Callback):
     """
     This callback is used to enable the TFT feature
-    `MindIO TFT <https://www.hiascend.com/document/detail/zh/mindx-dl/600/clusterscheduling/ref/mindiottp/mindiotft001.html>`_
+    `MindIO TFT <https://www.hiascend.com/document/detail/zh/mindx-dl/60rc2/mindio/mindiottp/mindiottp001.html>`_
     and will execute TFT operations during training process, such as TFT init, report and exception handle.
 
     Note:
@@ -339,6 +340,7 @@ class TrainFaultTolerance(Callback):
         self.learning_rate = None
         self.has_init_replica = False
         self.is_uce_rank = False
+        self.stop_been_called = False
 
         self.assign = mindspore.ops.Assign()
         self.g_one = Parameter(Tensor([1], dtype=mstype.int32))
@@ -380,9 +382,11 @@ class TrainFaultTolerance(Callback):
             _tft_handler.init(config=None)
             self.tft = _tft_handler.get_tft()
             logger.warning(f"TFT handle init ok.")
+        mode = context.get_context("mode")
         device_target = context.get_context("device_target")
-        if device_target != "Ascend":
-            raise ValueError(f"MindIO adataper only support on Ascend device but got device {device_target}!")
+        if device_target != "Ascend" or mode != context.GRAPH_MODE:
+            raise ValueError(f"MindIO adataper only support on Ascend device with GRAPH Mode!"
+                             f"device:{device_target}, run mode: {mode}")
 
     def _is_params_consistent(self):
         for key, param in self.cb_params.train_network.parameters_and_names():

mindspore/train/data_sink.py

@@ -16,7 +16,7 @@
 from functools import wraps
 import mindspore.ops as ops
 from mindspore import context
-from mindspore.common.dtype import _pytype_to_dtype
+from mindspore.common.dtype import pytype_to_dtype
 from mindspore.common.api import jit
 from mindspore.train._utils import _exec_datagraph, _get_types_and_shapes, enable_data_broadcast
 from mindspore.train.dataset_helper import _has_dynamic_shape, _check_inputs
@@ -61,7 +61,7 @@ def _init_sink_dataset(dataset, sink_size, input_signature, create_info):
         _check_inputs(input_signature, dataset_shapes, dataset_types)
 
     queue_name = transfer_dataset.queue_name
-    if _need_to_full():
+    if _need_to_full() and context.get_context('mode') == context.GRAPH_MODE:
         device_num = _get_device_num() // _get_pipeline_stages()
         dataset_shapes = _to_full_shapes(dataset_shapes, device_num)
     next_op = ops.GetNext(dataset_types, dataset_shapes, len(dataset_types), queue_name)
@@ -94,12 +94,12 @@ def _get_next_op(dataset, ori_next_op, is_info_queue):
 
     queue_name = dataset.__transfer_dataset__.queue_name
     dataset_types, dataset_shapes = dataset.__transfer_dataset__.get_data_info()
-    dataset_types = [_pytype_to_dtype(x) for x in dataset_types]  # pylint:disable=protected-access
+    dataset_types = [pytype_to_dtype(x) for x in dataset_types]
     key = str(dataset_types) + str(dataset_shapes)
     if key in dataset.__sink_aux__.next_ops:
         next_op = dataset.__sink_aux__.next_ops[key]
     else:
-        if _need_to_full():
+        if _need_to_full() and context.get_context('mode') == context.GRAPH_MODE:
             device_num = _get_device_num() // _get_pipeline_stages()
             dataset_shapes = _to_full_shapes(dataset_shapes, device_num)
         next_op = ops.GetNext(dataset_types, dataset_shapes, len(dataset_types), queue_name)

mindspore/train/dataset_helper.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2025 Huawei Technologies Co., Ltd
+# Copyright 2020 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.
@@ -20,8 +20,8 @@ import copy
 
 from mindspore import _checkparam as Validator
 from mindspore import log as logger
-from mindspore.common.dynamic_shape._auto_dynamic import is_auto_dynamic, convert_new_shapes
-from mindspore.common.dtype import _pytype_to_dtype
+from mindspore.common._auto_dynamic import is_auto_dynamic, convert_new_shapes
+from mindspore.common.dtype import pytype_to_dtype
 from mindspore.common.api import _cell_graph_executor, _is_args_fullmode, ARG_SPECIFIED
 from mindspore.common._utils import is_shape_unknown
 from mindspore.dataset.core import config as dataset_config
@@ -34,7 +34,7 @@ from mindspore.parallel._utils import _get_device_num, _get_global_rank, _need_t
     _origin_shapes, _dynamic_shape_for_dataset
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.ops import operations as P
-from mindspore.common.dynamic_shape.auto_dynamic_shape import _auto_dynamic_shape
+from mindspore.common.auto_dynamic_shape import _auto_dynamic_shape
 
 
 def _send_data(dataset, epoch_num):
@@ -275,7 +275,7 @@ def connect_network_with_dataset(network, dataset_helper):
         # Need to do full_batch for shapes which also do in the _DatasetIterMSLoopSink
         if _need_to_full():
             dataset_shapes = _to_full_shapes(dataset_shapes, _get_device_num() // _get_pipeline_stages())
-        dataset_types = [_pytype_to_dtype(x) for x in dataset_types]  # pylint:disable=protected-access
+        dataset_types = [pytype_to_dtype(x) for x in dataset_types]
         if not is_dynamic:
             dataset_shapes = _auto_dynamic_shape.auto_dynamic_generate_compile_args(dataset_shapes, True)
         key = str(dataset_types) + str(dataset_shapes)

mindspore/train/model.py

@@ -156,7 +156,11 @@ def _handle_exception_info(obj, uce_env, tft, e):
         tft.tft_report_error(tft.ReportState.RS_UCE.value)
     elif "HCCEError" in e_str:
         logger.warning("uce wrapper caught HCCEError")
-        tft.tft_report_error(tft.ReportState.RS_HCCL_FAILED.value)
+        if  obj.stop_been_called:
+            logger.warning("Received HCCEError after force stop been called, so report force stopped error to MindIO.")
+            tft.tft_report_error(tft.ReportState.RS_NORMAL.value)
+        else:
+            tft.tft_report_error(tft.ReportState.RS_HCCL_FAILED.value)
     elif "ForceStopError" in e_str:
         logger.warning("uce wrapper caught RuntimeError ForceStopError")
         force_stop_err = tft.ReportState.RS_NORMAL.value
@@ -266,6 +270,7 @@ def _handle_tft(func):
                         ret = obj.tft.tft_wait_next_action()
                         if ret == obj.tft.Action.EXIT.value:
                             raise e
+                        obj.stop_been_called = False
                         repair_step = obj.tft.tft_get_repair_step()
                         logger.warning(
                             "uce wrapper caught repair finish REPAIR STEP: {} batch_num:{}".format(repair_step,
@@ -303,6 +308,9 @@ def _check_tft():
         ascend_target = MSContext.get_instance().get_ascend_soc_version()
         if ascend_target == 'ascend910':
             raise ValueError("TFT is not supported when using ascend910")
+        ms_mode = context.get_context("mode")
+        if ms_mode != mindspore.GRAPH_MODE:
+            raise ValueError("TFT is only supported in GRAPH_MODE")
         jit_level = context.get_context("jit_level")
         if jit_level == "O2" and ("UCE:1" in tft_env or "ARF:1" in tft_env):
             raise ValueError("TFT is not supported when using jit_level == O2")
@@ -812,7 +820,7 @@ class Model:
         """
         if os.environ.get("MS_ENABLE_CKPT_D2H_ASYNC") != "1":
             return
-        if context.get_context("device_target") == "Ascend":
+        if (context.get_context("mode") == context.GRAPH_MODE) and (context.get_context("device_target") == "Ascend"):
             cb_params.need_ckpt, cb_params.save_checkpoint_steps, \
             cb_params.last_triggered_step = self._check_need_ckpt(cb_params.list_callback)
             logger.info(f"need_ckpt:{cb_params.need_ckpt},"
@@ -880,8 +888,8 @@ class Model:
             sink_size (int): Control the amount of data in each sink. Default: -1.
             epoch (int): Total number of iterations on the data. Default: 1.
         """
-        if context.get_context("device_target") != "Ascend":
-            raise RuntimeError('Pre-init process only supports Ascend target currently.')
+        if context.get_context("mode") != context.GRAPH_MODE or context.get_context("device_target") != "Ascend":
+            raise RuntimeError('Pre-init process only supports GRAPH MODE and Ascend target currently.')
 
         if not train_dataset and not valid_dataset:
             raise ValueError("The argument 'train_dataset' and 'valid_dataset' can not both be None or empty.")
@@ -1212,6 +1220,8 @@ class Model:
         if not enable_recovery:
             self.enable_recovery = False
         else:
+            if context.get_context("mode") != context.GRAPH_MODE:
+                raise RuntimeError("Recovery for training only support graph mode currently.")
             self.enable_recovery = enable_recovery and _is_role_worker()
 
     def _check_need_load_ckpt(self, cb_params, dataset_size, sink_size=-1):
@@ -2189,6 +2199,9 @@ class Model:
             dataset_sink_mode (bool): Determines whether to pass the data through dataset channel.
             sink_size (int): Control the amount of data in each sink.
         """
+        if context.get_context("mode") != context.GRAPH_MODE:
+            raise RuntimeError("Pre-compile process that generate parameter layout for the train network "
+                               "only supports GRAPH MODE and Ascend target currently.")
         if _get_parallel_mode() not in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
             raise RuntimeError("'infer_train_layout' only supports 'semi_auto_parallel' and 'auto_parallel' "
                                "mode, but got {}.".format(_get_parallel_mode()))
@@ -2348,6 +2361,9 @@ class Model:
             >>> predict_map = model.infer_predict_layout(inputs)
         """
         _init_auto_parallel_context(self._network)
+        if context.get_context("mode") != context.GRAPH_MODE:
+            raise RuntimeError("Pre-compile process that generate parameter layout for the predict network "
+                               "only supports GRAPH MODE and Ascend target currently.")
         if _get_parallel_mode() not in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
             raise RuntimeError('Infer predict layout only supports semi auto parallel and auto parallel mode.')
         _parallel_predict_check()

mindspore/train/serialization.py

@@ -52,6 +52,7 @@ from mindspore.log import vlog_print
 from mindspore._checkparam import check_input_data, check_input_dataset
 from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
+from mindspore.common import np_dtype
 from mindspore.common.api import _cell_graph_executor as _executor
 from mindspore.common.api import _JitExecutor
 from mindspore.common.api import _get_parameter_layout
@@ -85,9 +86,12 @@ tensor_to_ms_type = {"Int8": mstype.int8, "UInt8": mstype.uint8, "Int16": mstype
                      "Float16": mstype.float16, "Float32": mstype.float32, "Float64": mstype.float64,
                      "Bool": mstype.bool_, "str": mstype.string, "BFloat16": mstype.bfloat16, "Int4": mstype.qint4x2}
 
-_tensor_to_np_type = {"Int8": np.int8, "UInt8": np.uint8, "Int16": np.int16, "UInt16": np.uint16,
-                      "Int32": np.int32, "UInt32": np.uint32, "Int64": np.int64, "UInt64": np.uint64,
-                      "Float16": np.float16, "Float32": np.float32, "Float64": np.float64, "Bool": np.bool_, "str": "U"}
+tensor_to_np_type = {"Int8": np.int8, "UInt8": np.uint8, "Int16": np.int16, "UInt16": np.uint16,
+                     "Int32": np.int32, "UInt32": np.uint32, "Int64": np.int64, "UInt64": np.uint64,
+                     "Float16": np.float16, "Float32": np.float32, "Float64": np.float64, "Bool": np.bool_, "str": "U"}
+
+if hasattr(np_dtype, "bfloat16"):
+    tensor_to_np_type["BFloat16"] = np_dtype.bfloat16
 
 np_type_convert = {"int32": np.int32, "float32": np.float32, "float16": np.float16, "float64": np.float64}
 
@@ -110,21 +114,6 @@ INT_64_MAX = 9223372036854775807
 cpu_cast = Cast().set_device("CPU")
 
 _ckpt_fs = FileSystem()
-_ckpt_fs_initialized = False
-
-
-def tensor_to_np_type(tensor_type_str):
-    """tensor to numpy type"""
-    if tensor_type_str == "BFloat16":
-        from mindspore.common import np_dtype
-        if not np_dtype.np_dtype_valid(True):
-            raise TypeError(
-                "The Numpy bfloat16 data type is not supported now, please ensure that the current "
-                "Numpy version is not less than the version when the mindspore is compiled, "
-                "and the major versions are same."
-            )
-        return np_dtype.bfloat16
-    return _tensor_to_np_type.get(tensor_type_str)
 
 
 def init_ckpt_file_system(fs: FileSystem):
@@ -134,12 +123,8 @@ def init_ckpt_file_system(fs: FileSystem):
     _register_basic_file_system(fs)
 
 
-def _ensure_ckpt_fs_initialized():
-    """Ensure checkpoint file system is initialized"""
-    global _ckpt_fs_initialized
-    if not _ckpt_fs_initialized:
-        init_ckpt_file_system(_ckpt_fs)
-        _ckpt_fs_initialized = True
+# Initialize checkpoint file system
+init_ckpt_file_system(_ckpt_fs)
 
 
 def _wait_async_process_save_ckpt():
@@ -473,7 +458,7 @@ def _exec_save(ckpt_file_name, data_list, enc_key=None, enc_mode="AES-GCM", map_
                                f"simultaneously modified a file.")
             elif _ckpt_fs.backend != "mindio":
                 os.rename(tmp_name, ckpt_file_name)
-                os.chmod(ckpt_file_name, stat.S_IRUSR)
+            os.chmod(ckpt_file_name, stat.S_IRUSR)
     except BaseException as e:
         logger.critical("Failed to save the checkpoint file %s. Maybe don't have the permission to write files, "
                         "or the disk space is insufficient and so on.", ckpt_file_name)
@@ -733,7 +718,6 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
           <https://mindspore.cn/tutorials/en/master/beginner/save_load.html#saving-and-loading-the-model-weight>`_
     """
     start_save_time = time.time()
-    _ensure_ckpt_fs_initialized()
     ckpt_file_name = _check_save_obj_and_ckpt_file_name(save_obj, ckpt_file_name, format)
     integrated_save = Validator.check_bool(integrated_save)
     async_save = _check_async_save(async_save)
@@ -1284,7 +1268,11 @@ def _load_into_param_dict(ckpt_file_name, parameter_dict, specify_prefix, filter
                 continue
             data = element.tensor.tensor_content
             data_type = element.tensor.tensor_type
+            np_type = tensor_to_np_type.get(data_type)
             ms_type = tensor_to_ms_type[data_type]
+            if data_type == 'str':
+                str_length = int(len(data) / 4)
+                np_type = np_type + str(str_length)
             param_data_list.append(data)
             if (element_id == len(checkpoint_list.value) - 1) or \
                     (element.tag != checkpoint_list.value[element_id + 1].tag):
@@ -1292,8 +1280,6 @@ def _load_into_param_dict(ckpt_file_name, parameter_dict, specify_prefix, filter
                 param_data_list.clear()
                 dims = element.tensor.dims
                 if data_type == 'str':
-                    str_length = int(len(data) / 4)
-                    np_type = "U" + str(str_length)
                     str_value = np.frombuffer(new_data, np_type)
                     parameter_dict[element.tag] = str(str_value[0])
                 else:
@@ -1400,7 +1386,6 @@ def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=N
     """
     start_load_time = time.time()
     vlog_print("1", "ME", __file__, sys._getframe().f_lineno, "Begin load checkpoint.")
-    _ensure_ckpt_fs_initialized()
     specify_prefix = _check_prefix(specify_prefix)
     filter_prefix = _check_prefix(filter_prefix)
     dec_key = Validator.check_isinstance('dec_key', dec_key, (type(None), bytes))
@@ -2213,11 +2198,6 @@ def _save_onnx(net, file_name, *inputs, **kwargs):
         file_name += ".onnx"
     if os.path.exists(file_name):
         os.chmod(file_name, stat.S_IWUSR)
-    else:
-        dir_path = os.path.dirname(file_name)
-        if not os.path.exists(dir_path):
-            os.makedirs(dir_path, mode=0o700, exist_ok=True)
-        os.chmod(dir_path, 0o700)
     with open(file_name, 'wb') as f:
         f.write(onnx_stream)
         os.chmod(file_name, stat.S_IRUSR)
@@ -2614,7 +2594,7 @@ def parse_print(print_file_name):
                 dims = print_.tensor.dims
                 data_type = print_.tensor.tensor_type
                 data = print_.tensor.tensor_content
-                np_type = tensor_to_np_type(data_type)
+                np_type = tensor_to_np_type.get(data_type)
                 param_data = np.fromstring(data, np_type)
                 ms_type = tensor_to_ms_type.get(data_type)
                 if dims and dims != [0]:

mindspore/train/train_thor/model_thor.py

@@ -29,7 +29,7 @@ from mindspore import nn
 from mindspore.train.model import Model
 from mindspore.train.dataset_helper import connect_network_with_dataset
 from mindspore.parallel._utils import _need_to_full, _to_full_tensor
-from mindspore.common.dtype import _pytype_to_dtype
+from mindspore.common.dtype import pytype_to_dtype
 from mindspore._c_expression import init_exec_dataset
 from mindspore.train.train_thor.dataset_helper import DatasetHelper
 
@@ -46,7 +46,7 @@ def _convert_to_ms_type(types):
     """
     ms_types = []
     for numpy_type in types:
-        ms_type = _pytype_to_dtype(numpy_type)  # pylint:disable=protected-access
+        ms_type = pytype_to_dtype(numpy_type)
         ms_types.append(ms_type)
     return ms_types
 

mindspore/utils/hooks.py

@@ -0,0 +1,81 @@
+# 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.
+# ============================================================================
+"""hooks"""
+from collections import OrderedDict
+import weakref
+from typing import Any, Tuple
+
+
+class _RemovableHandle:
+    r"""
+    A handle which provides the capability to remove a hook.
+
+    Args:
+        hooks_dict (dict): A dictionary of hooks, indexed by hook `id`.
+
+    Keyword Args:
+        extra_dict (Union[dict, list[dict]], optional): An additional dictionary or list of
+            dictionaries whose keys will be deleted when the same keys are
+            removed from `hooks_dict`. Default ``None``.
+    """
+
+    id: int
+    next_id: int = 0
+
+    def __init__(self, hooks_dict: Any, *, extra_dict: Any = None) -> None:
+        self.hooks_dict_ref = weakref.ref(hooks_dict)
+        self.id = _RemovableHandle.next_id
+        _RemovableHandle.next_id += 1
+
+        self.extra_dict_ref: Tuple = ()
+        if isinstance(extra_dict, dict):
+            self.extra_dict_ref = (weakref.ref(extra_dict),)
+        elif isinstance(extra_dict, list):
+            self.extra_dict_ref = tuple(weakref.ref(d) for d in extra_dict)
+
+    def remove(self) -> None:
+        hooks_dict = self.hooks_dict_ref()
+        if hooks_dict is not None and self.id in hooks_dict:
+            del hooks_dict[self.id]
+
+        for ref in self.extra_dict_ref:
+            extra_dict = ref()
+            if extra_dict is not None and self.id in extra_dict:
+                del extra_dict[self.id]
+
+    def __getstate__(self):
+        if self.extra_dict_ref is None:
+            return (self.hooks_dict_ref(), self.id)
+        return (self.hooks_dict_ref(), self.id, tuple(ref() for ref in self.extra_dict_ref))
+
+    def __setstate__(self, state) -> None:
+        if state[0] is None:
+            # create a dead reference
+            self.hooks_dict_ref = weakref.ref(OrderedDict())
+        else:
+            self.hooks_dict_ref = weakref.ref(state[0])
+        self.id = state[1]
+        _RemovableHandle.next_id = max(_RemovableHandle.next_id, self.id + 1)
+
+        if len(state) < 3 or state[2] is None:
+            self.extra_dict_ref = ()
+        else:
+            self.extra_dict_ref = tuple(weakref.ref(d) for d in state[2])
+
+    def __enter__(self) -> "_RemovableHandle":
+        return self
+
+    def __exit__(self, type: Any, value: Any, tb: Any) -> None:
+        self.remove()

mindspore/utils/utils.py

@@ -132,16 +132,16 @@ class TftHandle:
         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("}", "")
-                all_opts = [part.strip() for part in tft_env.split(",")] + ["TTP:1"]
-                os.environ["MS_ENABLE_TFT"] = "{" + ",".join(all_opts) + "}"
+            logger.warning(f"Turn on TTP config when using ARF.")
+            if "TTP:1,UCE:1,ARF:1" not in tft_env:
+                os.environ["MS_ENABLE_TFT"] = "{TTP:1,ARF:1}"
             os.environ["MS_ENABLE_RECOVERY"] = "1"
 
+        mode = context.get_context("mode")
         device_target = context.get_context("device_target")
-        if device_target != "Ascend":
-            logger.warning(f"MindIO adataper only support on Ascend device but got device {device_target}!")
+        if device_target != "Ascend" or mode != context.GRAPH_MODE:
+            logger.warning(f"MindIO adataper only support on Ascend device with GRAPH Mode!"
+                           f"device:{device_target}, run mode: {mode}")
             return
 
         ctrl_port = int(os.getenv("MS_TFT_PORT"))
@@ -154,7 +154,7 @@ class TftHandle:
             from mindio_ttp import framework_ttp as tft
             self.tft = tft
         except BaseException as e:
-            raise ModuleNotFoundError(f"Module not found. Detail info {str(e)}")
+            raise ModuleNotFoundError(f"Module nopt found. Detail info {str(e)}")
         world_size = int(os.getenv("MS_WORKER_NUM"))  # from msrun
         cur_rank = int(os.getenv("MS_NODE_ID"))  # from msrun
         enable_local_copy = False

mindspore/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mindspore
-Version: 2.7.0
+Version: 2.7.0rc1
 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