mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/profiler/profiler_action_controller.py

@@ -13,45 +13,41 @@
 # limitations under the License.
 # ============================================================================
 """Profiler Action Controller"""
+__all__ = []
+
 from functools import partial
-from typing import Dict, Optional, Callable, Any
+from typing import Optional, Callable, Any, Dict
 
 from mindspore.profiler.profiler_interface import ProfilerInterface
 from mindspore.profiler.schedule import ProfilerAction
-
 from mindspore import log as logger
 
-__all__ = []
-
 
 class ProfilerActionController:
     """
     A controller class for managing profiler actions and transitions.
 
     This class handles the actions and transitions between different profiler states.
-    It uses two maps, abnormal_action_map and normal_action_map, to determine the actions
-    to take based on the previous and current profiler actions.
+    It uses an action_map to determine the actions to take based on the previous and
+    current profiler actions.
 
     Attributes:
-        profiler: The profiler instance associated with this controller.
         prof_interface (ProfilerInterface): The profiler interface instance.
         on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
-        abnormal_action_map (Dict): A map of abnormal transitions and their corresponding actions.
-        normal_action_map (Dict): A map of normal transitions and their corresponding actions.
+        action_map (Dict): A map of state transitions and their corresponding actions.
     """
 
     def __init__(self, prof_interface: ProfilerInterface, on_trace_ready: Optional[Callable[..., Any]] = None) -> None:
         """
-        Initializes a new instance of ProfActionController.
+        Initializes a new instance of ProfilerActionController.
 
         Args:
             prof_interface (ProfilerInterface): The profiler interface instance.
             on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
         """
         self.prof_interface = prof_interface
-        self.abnormal_action_map: Dict = self.init_abnormal_action_map()
-        self.normal_action_map: Dict = self.init_normal_action_map()
         self.on_trace_ready = on_trace_ready
+        self.action_map = self._init_action_map()
 
     def _trace_ready(self):
         """
@@ -60,84 +56,38 @@ class ProfilerActionController:
         This method is called when the trace is ready to notify the callback function.
         """
         if self.on_trace_ready:
-            self.on_trace_ready()
+            self.on_trace_ready(self.prof_interface)
 
     def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
         """
-        Handles actions between previous action and latter action
+        Handles actions between previous action and current action
 
         Args:
             prev_action: The previous state
-            current_action: the latter state
-        """
-        # Check whether the action is in the abnormal map
-        action_list = self.abnormal_action_map.get((prev_action, current_action), [])
-        if not action_list:
-            if isinstance(prev_action, ProfilerAction) and isinstance(current_action, ProfilerAction):
-                # Check whether the action is in the normal map
-                action_list = self.handle_normal_action(prev_action, current_action)
-        if not action_list:
-            return
-        for action in action_list:
-            action()
-
-    def handle_normal_action(self, start_state: ProfilerAction, end_state: ProfilerAction) -> list:
+            current_action: the current state
         """
-        Obtain the action in the normal state
+        # Get the action list for this state transition
+        action_list = self.action_map.get((prev_action, current_action))
 
-        Args:
-            start_state: The previous state
-            end_state: the latter state
+        if action_list:
+            logger.info(f"ProfilerAction transition: {prev_action} -> {current_action}")
+            for action in action_list:
+                action()
 
-        Returns:
-            process_action list
-        """
-        process_action = []
-        initial_state = start_state
-
-        # Handle special case for ProfilerAction.RECORD_AND_SAVE to ProfilerAction.RECORD_AND_SAVE transition
-        if start_state == ProfilerAction.RECORD_AND_SAVE and end_state == ProfilerAction.RECORD_AND_SAVE:
-            process_action = [self.prof_interface.stop, self.prof_interface.finalize,
-                              self._trace_ready, self.prof_interface.clear, self.prof_interface.init,
-                              self.prof_interface.start]
-        else:
-            while start_state != end_state:
-                process_action.extend(self.normal_action_map[start_state])
-                start_state = ProfilerAction.get_by_value((start_state.value + 1) % len(ProfilerAction))
-
-            # Handle special cases for NONE to NONE, WARM_UP to WARM_UP, RECORD to RECORD transitions
-            if initial_state == start_state and initial_state != ProfilerAction.RECORD_AND_SAVE:
-                process_action = []
-
-        return process_action
-
-    def init_normal_action_map(self) -> dict:
+    def _init_action_map(self) -> Dict:
         """
-        Generate a normal action map
+        Initialize the action map for state transitions.
 
         Returns:
-            normal_action_map map
+            Dict: A map of state transitions and their corresponding actions.
         """
-        return {
-            ProfilerAction.NONE: [self.prof_interface.init],
-            ProfilerAction.WARM_UP: [self.prof_interface.start],
-            ProfilerAction.RECORD: [],
-            ProfilerAction.RECORD_AND_SAVE: [
-                self.prof_interface.stop,
-                self.prof_interface.finalize,
-                self._trace_ready,
-                self.prof_interface.clear
-            ]
-        }
-
-    def init_abnormal_action_map(self) -> dict:
-        """
-        Generate a abnormal action map
+        action_map = {
+            (ProfilerAction.NONE, ProfilerAction.NONE): [],
+            (ProfilerAction.NONE, ProfilerAction.WARM_UP): [self.prof_interface.init],
+            (ProfilerAction.NONE, ProfilerAction.RECORD): [self.prof_interface.init, self.prof_interface.start],
+            (ProfilerAction.NONE, ProfilerAction.RECORD_AND_SAVE): [self.prof_interface.init,
+                                                                    self.prof_interface.start],
 
-        Returns:
-            abnormal_action_map map
-        """
-        return {
             (ProfilerAction.WARM_UP, ProfilerAction.NONE): [
                 partial(logger.warning, "Incorrect schedule: WARMUP followed by NONE"),
                 self.prof_interface.start,
@@ -145,6 +95,10 @@ class ProfilerActionController:
                 self.prof_interface.finalize,
                 self.prof_interface.clear
             ],
+            (ProfilerAction.WARM_UP, ProfilerAction.WARM_UP): [],
+            (ProfilerAction.WARM_UP, ProfilerAction.RECORD): [self.prof_interface.start],
+            (ProfilerAction.WARM_UP, ProfilerAction.RECORD_AND_SAVE): [self.prof_interface.start],
+
             (ProfilerAction.RECORD, ProfilerAction.NONE): [
                 partial(logger.warning, "Incorrect schedule: RECORD followed by NONE"),
                 self.prof_interface.stop,
@@ -157,7 +111,40 @@ class ProfilerActionController:
                 self.prof_interface.finalize,
                 self.prof_interface.clear
             ],
-            # used for exit action
+            (ProfilerAction.RECORD, ProfilerAction.RECORD): [],
+            (ProfilerAction.RECORD, ProfilerAction.RECORD_AND_SAVE): [],
+
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.NONE): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.WARM_UP): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.RECORD): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+                self.prof_interface.start
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.RECORD_AND_SAVE): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+                self.prof_interface.start
+            ],
+
+            # Used for exit action
             (ProfilerAction.WARM_UP, None): [
                 partial(logger.warning,
                         "Incorrect schedule: Stop profiler while current state is WARMUP "
@@ -185,3 +172,4 @@ class ProfilerActionController:
                 self.prof_interface.clear
             ]
         }
+        return action_map

mindspore/profiler/profiler_interface.py

@@ -76,14 +76,14 @@ class ProfilerInterface:
         logger.info("ProfilerInterface stop")
 
     @classmethod
-    def analyse(cls):
+    def analyse(cls, **kwargs):
         """ProfilerInterface analyse"""
         if not cls.is_initialized:
             logger.warning("ProfilerInterface analyse failed, profiler has not been initialized.")
             return
 
         for profiler in cls.platform_profilers_set:
-            profiler.analyse()
+            profiler.analyse(**kwargs)
 
         logger.info("ProfilerInterface analyse")
 

mindspore/profiler/schedule.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """Profiler Schedule"""
+__all__ = ["ProfilerAction", "Schedule"]
+
 from enum import Enum
 
 from mindspore import log as logger
 
-__all__ = ["ProfilerAction", "Schedule"]
-
 
 class ProfilerAction(Enum):
     """
@@ -83,8 +83,14 @@ class Schedule:
             must be greater than or equal to 0. Default value: ``0``.
         repeat (int, optional): The number of times to repeat the cycle.
             If repeat is set to 0, the Profiler will determine the repeat value based on the number of times the model
-            is trained, which will generate one more performance data with incomplete collection. The data in the last
-            step is abnormal data that users do not need to pay attention to. Default value: ``0``.
+            is trained, for example, if the total training steps are 100, wait+active+warmup=10, skip_first=10,
+            Then repeat=(100-10)/10=9, indicating that the execution is repeated 9 timeswhich will
+            generate one more performance data with incomplete collection. The data in the last step is abnormal data
+            that users do not need to pay attention to. Suggest configuring integers greater than 0. When using
+            cluster analysis tools or MindStudio Insight to view, it is recommended to configure it as 1;
+            If the setting is greater than 1, the collected performance data folder needs to be divided into repeat and
+            other parts, placed in different folders for re-parsing, and classified according to the timestamp order in
+            the folder name. Default value: ``0``.
         skip_first (int, optional): The number of steps to skip at the beginning. Must be greater than or equal to 0.
             Default value: ``0``
 

mindspore/rewrite/common/config.py

@@ -16,6 +16,7 @@
 MindSpore rewrite configurations.
 """
 
+
 def clear_caches():
     """clear rewrite caches"""
     from ..parsers import AssignParser

mindspore/rewrite/common/namer.py

@@ -222,6 +222,7 @@ class ClassNamer(Namer):
 
         super(ClassNamer, self).add_name(name + self._prefix)
 
+
 class FunctionNamer(Namer):
     """
     Used for unique-ing function name in a network.

mindspore/rewrite/common/namespace.py

@@ -34,6 +34,7 @@ _ms_cells_to_subtree = False
 # Paths of modules which will not be considered as third party module
 _ignore_third_party_paths = []
 
+
 def is_subtree(cls_inst):
     """Determine whether 'cls_inst' is a subtree."""
     cls_name = type(cls_inst).__name__

mindspore/rewrite/node/node.py

@@ -124,9 +124,14 @@ class Node:
         self._init_cls = None
 
     @classmethod
-    def create_call_method(cls, ast_node: Optional[ast.AST], targets: [Union[ScopedValue, str]],
-                           func_name: Union[ScopedValue, str], args: [ScopedValue] = None,
-                           kwargs: {str: ScopedValue}=None, name: str = ""):
+    def create_call_method(
+            cls,
+            ast_node: Optional[ast.AST],
+            targets: [Union[ScopedValue, str]],
+            func_name: Union[ScopedValue, str],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            name: str = ""):
         """
         Class method of Node. Instantiate an instance of node whose type is CallCell. A CallCell node represents an
         invoking to cell-op.
@@ -227,8 +232,12 @@ class Node:
         return cls(NodeType.MathOps, ast_node, targets, op_type, args, None, name, None)
 
     @staticmethod
-    def _create_call_function(function: FunctionType, targets: [Union[ScopedValue, str]], args: [ScopedValue] = None,
-                              kwargs: {str: ScopedValue}=None):
+    def _create_call_function(
+            function: FunctionType,
+            targets: [Union[ScopedValue, str]],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None  # pylint: disable=bad-whitespace
+    ):
         """
         Create a node that corresponds to a function call.
 
@@ -275,9 +284,14 @@ class Node:
         return CallFunction(targets, func_name, args, kwargs, node_name, ast_node, None, None, func_obj, False)
 
     @staticmethod
-    def create_call_op(op: Union[Cell, Primitive], ast_node: Optional[ast.AST], targets: [Union[ScopedValue, str]],
-                       args: [ScopedValue] = None, kwargs: {str: ScopedValue}=None, node_name: str = "",
-                       is_sub_net: bool = False):
+    def create_call_op(
+            op: Union[Cell, Primitive],
+            ast_node: Optional[ast.AST],
+            targets: [Union[ScopedValue, str]],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            node_name: str = "",
+            is_sub_net: bool = False):
         """
         Static method of Node. Instantiate an instance of node whose type is `CallCell` or `CallPrimitive`.
         If op is custom defined, it is treated by TreeNode.
@@ -325,9 +339,15 @@ class Node:
         return Node.create_call_buildin_op(op, ast_node, new_targets, func_name, args, kwargs, node_name)
 
     @classmethod
-    def create_call_buildin_op(cls, op: Union[Cell, Primitive], ast_node: Optional[ast.AST], targets: [ScopedValue],
-                               func_name: ScopedValue, args: [ScopedValue] = None, kwargs: {str: ScopedValue}=None,
-                               node_name: str = ""):
+    def create_call_buildin_op(
+            cls,
+            op: Union[Cell, Primitive],
+            ast_node: Optional[ast.AST],
+            targets: [ScopedValue],
+            func_name: ScopedValue,
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            node_name: str = ""):
         """
         Class method of Node. Instantiate an instance of node whose type is `CallCell` or `CallPrimitive`.
         A `CallCell` node represents an invoking to cell-op.

mindspore/rewrite/parsers/assign_parser.py

@@ -46,7 +46,7 @@ class AssignParser(Parser):
     """Parse ast.Assign in construct function to node of SymbolTree."""
 
     # Types for creating Cell Container node
-    types_for_cell_container = [SequentialCell,]
+    types_for_cell_container = [SequentialCell]
     # If mindspore built-in function to be parsered or skipped
     _skip_ms_function = False
     # Functions in black list will not be parsed

mindspore/rewrite/symbol_tree/symbol_tree.py

@@ -1503,7 +1503,7 @@ class SymbolTree(Observer, Observable, NodeManager):
         """
         # ast.Constant can be check without eval
         if isinstance(ast_node, ast.Constant):
-            return True, bool(ast.value)
+            return True, bool(ast_node.value)
         # Get the module where the code of ast_node is located
         file_path = inspect.getfile(type(self.get_origin_network()))
         module = None
@@ -1790,7 +1790,7 @@ class SymbolTree(Observer, Observable, NodeManager):
                         if idx > 0:
                             name_need_suffix[name] = suffix_alias(alias, idx)
                         break
-                    elif ast_node.module.startswith(path):
+                    if ast_node.module.startswith(path):
                         # e.g. origin code is 'from a.b import A' and new code is 'from a.b.c import A'
                         # then we just need to update name to A_{idx}
                         if idx > 0:

mindspore/run_check/_check_version.py

@@ -124,9 +124,9 @@ class GPUEnvChecker(EnvChecker):
         for path in self.cuda_lib_path:
             real_path = glob.glob(path + "/lib*/libcudart.so.*.*.*")
             # /usr/lib/x86_64-linux-gnu is a default dir for cuda10.1 on ubuntu.
-            if real_path == []:
+            if not real_path:
                 real_path = glob.glob(path + "/x86_64-linux-gnu/libcudart.so.*.*.*")
-            if real_path == []:
+            if not real_path:
                 continue
             ls_cudart = subprocess.run(["ls", real_path[0]], timeout=10, text=True,
                                        capture_output=True, check=False)
@@ -258,7 +258,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.6", "7.7"]
+        self.version = ["7.7", "7.8", "8.2"]
 
         # env
         self.path = os.getenv("PATH")
@@ -293,7 +293,7 @@ class AscendEnvChecker(EnvChecker):
 
         cur_version = self._read_version(self.compiler_version)
         custom_version_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                           "../lib/plugin/ascend/custom_ascendc_910/version.info")
+                                           "../lib/plugin/ascend/custom_ascendc_910b/version.info")
         with open(custom_version_path, 'r') as f:
             all_info = f.readlines()
             for line in all_info:
@@ -375,18 +375,15 @@ class AscendEnvChecker(EnvChecker):
         curr_path = os.path.realpath(os.path.dirname(__file__))
         cust_aicpu_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
         cust_aicore_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
-        cust_ascendc_ascend910_path = os.path.realpath(
-            os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_910"))
         cust_ascendc_ascend910b_path = os.path.realpath(
             os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_910b"))
         if os.getenv('ASCEND_CUSTOM_OPP_PATH'):
             os.environ['ASCEND_CUSTOM_OPP_PATH'] = os.environ['ASCEND_CUSTOM_OPP_PATH'] + ":" + \
-                                                   cust_ascendc_ascend910_path + ":" + cust_ascendc_ascend910b_path + \
-                                                   ":" + cust_aicore_path + ":" + cust_aicpu_path
-        else:
-            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_ascend910_path + ":" + \
                                                    cust_ascendc_ascend910b_path + ":" + cust_aicore_path + ":" + \
                                                    cust_aicpu_path
+        else:
+            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_ascend910b_path + ":" + cust_aicore_path + ":" + \
+                                                   cust_aicpu_path
         # Ignore ge infer missing error. To be removed after infers are completed.
         os.environ['FAST_IGNORE_INFER_ERROR'] = "1"
         os.environ['IGNORE_INFER_ERROR'] = "1"

mindspore/runtime/__init__.py

@@ -17,9 +17,10 @@
 The runtime interface.
 """
 
-from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity, set_kernel_launch_group
+from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity,\
+                                    set_kernel_launch_group, set_kernel_launch_capture
 from mindspore.runtime.memory import set_memory, memory_stats, memory_reserved, max_memory_reserved, empty_cache,\
-                                 reset_peak_memory_stats, memory_summary, memory_allocated,\
+                                 memory_replay, reset_peak_memory_stats, memory_summary, memory_allocated,\
                                  max_memory_allocated, reset_max_memory_reserved, reset_max_memory_allocated
 from mindspore.runtime.stream import Stream, synchronize, set_cur_stream, current_stream, \
     default_stream, communication_stream, StreamCtx
@@ -27,11 +28,12 @@ from mindspore.runtime.event import Event
 from .executor import launch_blocking
 
 __all__ = [
-    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity", "set_kernel_launch_group",
+    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity",
+    "set_kernel_launch_group", "set_kernel_launch_capture",
     "Stream", "communication_stream", "synchronize", "set_cur_stream", "current_stream", "default_stream", "StreamCtx",
-    "set_memory", "memory_stats", "memory_reserved", "max_memory_reserved", "empty_cache", "reset_peak_memory_stats",
-    "memory_summary", "memory_allocated", "max_memory_allocated", "reset_max_memory_reserved",
-    "reset_max_memory_allocated", "Event"
+    "set_memory", "memory_stats", "memory_reserved", "max_memory_reserved", "empty_cache", "memory_replay",
+    "reset_peak_memory_stats", "memory_summary", "memory_allocated", "max_memory_allocated",
+    "reset_max_memory_reserved", "reset_max_memory_allocated", "Event"
 ]
 
 __all__.sort()

mindspore/runtime/event.py

@@ -16,7 +16,6 @@
 from mindspore._c_expression import Event as Event_
 from mindspore._c_expression import Stream as Stream_
 from mindspore._c_expression import current_stream as current_stream_
-from mindspore import _checkparam as Validator
 from .device import _is_supported
 
 function_event_status = {'Event': False, 'wait': False}
@@ -71,9 +70,16 @@ class Event(Event_):
             function_event_status['Event'] = True
             if not _is_supported():
                 return
-        # pylint: disable=useless-super-delegation
-        Validator.check_bool(enable_timing, "enable_timing", "Event")
-        Validator.check_bool(blocking, "blocking", "Event")
+        if not isinstance(enable_timing, bool):
+            raise TypeError(
+                f"For 'Event', the 'enable_timing' must be a bool,"
+                f" but got {type(enable_timing).__name__}."
+            )
+        if not isinstance(blocking, bool):
+            raise TypeError(
+                f"For 'Event', the 'blocking' must be a bool,"
+                f" but got {type(blocking).__name__}."
+            )
         super().__init__(enable_timing, blocking)
 
     def record(self, stream=None):