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

mindspore/profiler/profiler.py

@@ -16,18 +16,18 @@
 import os
 import json
 import warnings
-from typing import Optional, Dict, Callable, Any, Iterable
+from typing import Optional, Dict, Callable, Any
 from sys import getsizeof
 from concurrent.futures import ProcessPoolExecutor, as_completed
 
 from mindspore import log as logger
-from mindspore.profiler.common.constant import ProfilerStepNameConstant, DeviceTarget, ProfilerActivity
+from mindspore.profiler.common.constant import ProfilerStepNameConstant, DeviceTarget
 from mindspore.profiler.common.profiler_context import ProfilerContext
 from mindspore.profiler.platform.npu_profiler import NPUProfilerAnalysis
 from mindspore.profiler.profiler_action_controller import ProfilerActionController
 from mindspore.profiler.experimental_config import _ExperimentalConfig
 from mindspore.profiler.profiler_interface import ProfilerInterface
-from mindspore.profiler.schedule import _default_schedule_fn, ProfilerAction
+from mindspore.profiler.schedule import _default_schedule_fn, ProfilerAction, Schedule
 from mindspore.profiler.common.record_function import RecordFunction
 from mindspore.profiler.common.path_manager import PathManager
 from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
@@ -111,9 +111,9 @@ def tensorboard_trace_handler(dir_name: str = None, worker_name: str = None,
         logger.warning("async_mode is not bool, set by default.")
         async_mode = False
 
-    def handler_fn(prof_inst) -> None:
+    def handler_fn() -> None:
         if analyse_flag:
-            prof_inst.analyse(async_mode=async_mode)
+            NPUProfilerAnalysis.online_analyse(async_mode=async_mode)
 
     return handler_fn
 
@@ -261,10 +261,9 @@ class Profiler:
         ...     # Profiler end
         ...     profiler.analyse()
     """
+    MAX_META_SIZE = 100 * 1024 * 1024  # 100MB
 
     def __init__(self, **kwargs) -> None:
-        logger.warning("'mindspore.Profiler' will be deprecated and removed in a future version. Please use the api "
-                       "'mindspore.profiler.profile' instead.")
         self._metadata: Dict[str, str] = {}
         self._prof_context: ProfilerContext = ProfilerContext()
         self._prof_context.set_params(**kwargs)
@@ -565,7 +564,7 @@ class Profiler:
             return
 
         add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
+        if getsizeof(self._metadata) + add_size < self.MAX_META_SIZE:
             if key in self._metadata:
                 logger.warning(f"{key} is already saved as metadata, override it.")
             self._metadata[key] = value
@@ -596,7 +595,7 @@ class Profiler:
             return
 
         add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
+        if getsizeof(self._metadata) + add_size < self.MAX_META_SIZE:
             try:
                 if key in self._metadata:
                     logger.warning(f"{key} is already saved as metadata, override it.")
@@ -697,32 +696,38 @@ class Profile:
     correspondence, cluster, etc data analysis.
 
     Args:
-        activities (Iterable, optional): The activities to collect.
+        start_profile (bool, optional): The start_profile parameter controls whether to enable or disable performance
+            data collection based on conditions. Default: ``True`` .
+        activities (list, optional): The activities to collect.
             Default: ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
 
             - ProfilerActivity.CPU: Collect MindSpore framework data.
             - ProfilerActivity.NPU: Collect CANN software stack and NPU data.
             - ProfilerActivity.GPU: Collect GPU data.
-        with_stack (bool, optional): (Ascend only) Whether to collect frame host call stack data
-            on the Python side. This
-            data is presented in the form of a flame graph in the timeline. When using this parameter, `activities` must
-            include ``ProfilerActivity.CPU``. Default value: ``False`` .
+        schedule (schedule, optional): Sets the action strategy for the capture, defined by the schedule class,
+            to be used with the step interface. Default: ``None``. Performance data of all steps is collected.
+            For details, see :class:`mindspore.profiler.schedule` .
+        on_trace_ready (Callable, optional): Sets the callback function to be executed when the performance data
+            is collected. Default: ``None``. It indicates that only performance data is collected, but not resolved.
+            For details, see :func:`mindspore.profiler.tensorboard_trace_handler` .
         profile_memory (bool, optional): (Ascend only) Whether to collect tensor memory data, collect when ``True`` .
             When using this parameter, `activities` must set to ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
             Collecting operator memory data when GE backend requires collecting from the first step.
             Default: ``False`` . The operator name currently collected by this parameter is incomplete.
             This issue will be resolved in later versions. It is recommended to use the environment variable
             ``MS_ALLOC_CONF`` instead.
-        data_process (bool, optional): (Ascend/GPU) Whether to collect data to prepare performance data.
-            Default value: ``False`` .
-        parallel_strategy (bool, optional): (Ascend only) Whether to collect parallel policy performance data.
-            Default value: ``False`` .
-        start_profile (bool, optional): The start_profile parameter controls whether to enable or disable performance
-            data collection based on conditions. Default: ``True`` .
+        with_stack (bool, optional): (Ascend only) Whether to collect frame host call stack data
+            on the Python side. This
+            data is presented in the form of a flame graph in the timeline. When using this parameter, `activities` must
+            include ``ProfilerActivity.CPU``. Default value: ``False`` .
         hbm_ddr (bool, optional): (Ascend only) Whether to collect On-Chip Memory/DDR read and write rate data,
             collect when True. Default: ``False`` .
         pcie (bool, optional): (Ascend only) Whether to collect PCIe bandwidth data, collect when True.
             Default: ``False`` .
+        data_process (bool, optional): (Ascend/GPU) Whether to collect data to prepare performance data.
+            Default value: ``False`` .
+        parallel_strategy (bool, optional): (Ascend only) Whether to collect parallel policy performance data.
+            Default value: ``False`` .
         sync_enable (bool, optional): (GPU only) Whether the profiler collects operators in a synchronous way.
             Default: ``True`` .
 
@@ -734,12 +739,6 @@ class Profile:
         record_shapes (bool, optional): (Ascend only) Whether to collect operator input tensor shapes data, collect
             when ``True`` . When using this parameter, `activities` must include ``ProfilerActivity.CPU``.
             Default: ``False``.
-        schedule (Callable, optional): Sets the action strategy for the capture, defined by the schedule class,
-            to be used with the step interface. Default: ``None``. Performance data of all steps is collected.
-            For details, see :class:`mindspore.profiler.schedule` .
-        on_trace_ready (Callable, optional): Sets the callback function to be executed when the performance data
-            is collected. Default: ``None``. It indicates that only performance data is collected, but not resolved.
-            For details, see :func:`mindspore.profiler.tensorboard_trace_handler` .
         experimental_config (_ExperimentalConfig, optional): expandable parameters can be configured in this
               configuration item. For details, see :class:`mindspore.profiler._ExperimentalConfig` .
     Raises:
@@ -804,54 +803,70 @@ class Profile:
         ...             prof.step()
     """
 
-    def __init__(self,
-                 activities: Optional[Iterable[ProfilerActivity]] = None,
-                 with_stack: bool = False,
-                 profile_memory: bool = False,
-                 data_process: bool = False,
-                 parallel_strategy: bool = False,
-                 start_profile: bool = True,
-                 hbm_ddr: bool = False,
-                 pcie: bool = False,
-                 sync_enable: bool = True,
-                 record_shapes: bool = False,
-                 schedule: Optional[Callable[[int], ProfilerAction]] = None,
-                 on_trace_ready: Optional[Callable[..., Any]] = None,
-                 experimental_config: Optional[_ExperimentalConfig] = None):
-        self._metadata: Dict[str, str] = {}
-        self._prof_context: ProfilerContext = ProfilerContext()
-        kwargs = {
-            "activities": activities,
-            "with_stack": with_stack,
-            "profile_memory": profile_memory,
-            "data_process": data_process,
-            "parallel_strategy": parallel_strategy,
-            "start_profile": start_profile,
-            "hbm_ddr": hbm_ddr,
-            "pcie": pcie,
-            "sync_enable": sync_enable,
-            "record_shapes": record_shapes,
-            "schedule": schedule,
-            "on_trace_ready": on_trace_ready,
-            "experimental_config": experimental_config,
-        }
-        self._prof_context.set_params(**kwargs)
-        self._has_started: bool = False
-        if schedule and isinstance(schedule, Callable):
-            self.schedule = schedule
-            # add step markers into the trace and table view
-            self.record_steps = True
-        else:
-            if schedule:
-                logger.warning("schedule is not Callable, set by default.")
-            self.schedule = _default_schedule_fn
-            self.record_steps = False
-        self._step_rec_fn: Optional[RecordFunction] = None
-        self.step_num = 0
-        self.current_action: ProfilerAction = self.schedule(self.step_num)
-        self.action_controller = ProfilerActionController(ProfilerInterface, self._prof_context.on_trace_ready)
-        if self._prof_context.start_profile:
-            self.start()
+    def __init__(
+            self,
+            activities: list = None,
+            with_stack: bool = False,
+            profile_memory: bool = False,
+            data_process: bool = False,
+            parallel_strategy: bool = False,
+            start_profile: bool = True,
+            hbm_ddr: bool = False,
+            pcie: bool = False,
+            sync_enable: bool = True,
+            record_shapes: bool = False,
+            schedule: Schedule = None,
+            on_trace_ready: Optional[Callable[..., Any]] = None,
+            experimental_config: Optional[_ExperimentalConfig] = None,
+    ):
+        self._activities = activities
+        self._with_stack = with_stack
+        self._profile_memory = profile_memory
+        self._data_process = data_process
+        self._parallel_strategy = parallel_strategy
+        self._start_profile = start_profile
+        self._hbm_ddr = hbm_ddr
+        self._pcie = pcie
+        self._sync_enable = sync_enable
+        self._record_shapes = record_shapes
+        self._schedule = schedule
+        self._on_trace_ready = on_trace_ready
+        self._experimental_config = experimental_config or _ExperimentalConfig()
+        self._profiler = Profiler(
+            profiler_level=self._experimental_config.profiler_level,
+            activities=self._activities,
+            aic_metrics=self._experimental_config.aic_metrics,
+            with_stack=self._with_stack,
+            profile_memory=self._profile_memory,
+            data_process=self._data_process,
+            parallel_strategy=self._parallel_strategy,
+            start_profile=self._start_profile,
+            l2_cache=self._experimental_config.l2_cache,
+            hbm_ddr=self._hbm_ddr,
+            pcie=self._pcie,
+            sync_enable=self._sync_enable,
+            record_shapes=self._record_shapes,
+            data_simplification=self._experimental_config.data_simplification,
+            mstx=self._experimental_config.mstx,
+            mstx_domain_include=self._experimental_config.mstx_domain_include,
+            mstx_domain_exclude=self._experimental_config.mstx_domain_exclude,
+            export_type=self._experimental_config.export_type,
+            sys_io=self._experimental_config.sys_io,
+            sys_interconnection=self._experimental_config.sys_interconnection,
+            host_sys=self._experimental_config.host_sys,
+            schedule=self._schedule,
+            on_trace_ready=self._on_trace_ready,
+        )
+
+    def __enter__(self) -> 'Profile':
+        self._profiler.__enter__()
+        return self
+
+    def __exit__(self, exe_type, exe_val, exc_tb):
+        self._profiler.__exit__(exe_type, exe_val, exc_tb)
+
+    def __del__(self):
+        self._profiler.__del__()
 
     def start(self) -> None:
         """
@@ -916,14 +931,7 @@ class Profile:
             ...         prof.step()
             ...     prof.stop()
         """
-        if self._has_started:
-            logger.warning("The profile has already started. Do not turn on again in the open state.")
-            return
-        self._has_started = True
-        self.action_controller.transit_action(ProfilerAction.NONE, self.current_action)
-        if self.record_steps:
-            self._step_rec_fn = RecordFunction(ProfilerStepNameConstant.PROFILER_STEP + str(self.step_num))
-            self._step_rec_fn.start()
+        self._profiler.start()
 
     def stop(self) -> None:
         """
@@ -987,13 +995,7 @@ class Profile:
             ...         prof.step()
             ...     prof.stop()
         """
-        if not self._has_started:
-            logger.error("The profile has not started. Do not turn off again in the closed state.")
-            return
-        self._has_started = False
-        if self.record_steps and self._step_rec_fn:
-            self._step_rec_fn.stop()
-        self.action_controller.transit_action(self.current_action, None)
+        self._profiler.stop()
 
     def step(self) -> None:
         """
@@ -1004,71 +1006,59 @@ class Profile:
             RuntimeError: If the `schedule` parameter is not set.
 
         Examples:
-            >>> import numpy as np
-            >>> import mindspore
-            >>> from mindspore import nn, context
-            >>> import mindspore.dataset as ds
-            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
-            >>>
-            >>> class Net(nn.Cell):
-            ...     def __init__(self):
-            ...         super(Net, self).__init__()
-            ...         self.fc = nn.Dense(2,2)
-            ...     def construct(self, x):
-            ...         return self.fc(x)
-            >>>
-            >>> def generator():
-            ...     for i in range(2):
-            ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
-            >>>
-            >>> def train(net):
-            ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
-            ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-            ...     data = ds.GeneratorDataset(generator, ["data", "label"])
-            ...     model = mindspore.train.Model(net, loss, optimizer)
-            ...     model.train(1, data)
-            >>>
-            >>> if __name__ == '__main__':
-            ...     # If the device_target is GPU, set the device_target to "GPU"
-            ...     context.set_context(mode=mindspore.GRAPH_MODE)
-            ...     mindspore.set_device("Ascend")
-            ...
-            ...     # Init Profiler
-            ...     experimental_config = mindspore.profiler._ExperimentalConfig(
-            ...                                 profiler_level=ProfilerLevel.Level0,
-            ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
-            ...                                 l2_cache=False,
-            ...                                 mstx=False,
-            ...                                 data_simplification=False,
-            ...                                 export_type=[ExportType.Text])
-            ...     steps = 10
-            ...     net = Net()
-            ...     # Note that the Profiler should be initialized before model.train
-            ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-            ...                                     schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
-            ...                                           repeat=1, skip_first=0),
-            ...                                     on_trace_ready=mindspore.profiler.
-            ...                                         tensorboard_trace_handler("./data"),
-            ...                                     profile_memory=False,
-            ...                                     experimental_config=experimental_config) as prof:
-            ...
-            ...         # Train Model
-            ...         for step in range(steps):
-            ...             train(net)
-            ...             prof.step()
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import nn, context
+        >>> import mindspore.dataset as ds
+        >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
+        >>>
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.fc = nn.Dense(2,2)
+        ...     def construct(self, x):
+        ...         return self.fc(x)
+        >>>
+        >>> def generator():
+        ...     for i in range(2):
+        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+        >>>
+        >>> def train(net):
+        ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+        ...     model = mindspore.train.Model(net, loss, optimizer)
+        ...     model.train(1, data)
+        >>>
+        >>> if __name__ == '__main__':
+        ...     # If the device_target is GPU, set the device_target to "GPU"
+        ...     context.set_context(mode=mindspore.GRAPH_MODE)
+        ...     mindspore.set_device("Ascend")
+        ...
+        ...     # Init Profiler
+        ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+        ...                                 profiler_level=ProfilerLevel.Level0,
+        ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
+        ...                                 l2_cache=False,
+        ...                                 mstx=False,
+        ...                                 data_simplification=False,
+        ...                                 export_type=[ExportType.Text])
+        ...     steps = 10
+        ...     net = Net()
+        ...     # Note that the Profiler should be initialized before model.train
+        ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+        ...                                     schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+        ...                                           repeat=1, skip_first=0),
+        ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+        ...                                     profile_memory=False,
+        ...                                     experimental_config=experimental_config) as prof:
+        ...
+        ...         # Train Model
+        ...         for step in range(steps):
+        ...             train(net)
+        ...             prof.step()
         """
-        if not self._has_started:
-            logger.error("profile is stopped, step takes no effect!")
-            return
-        if self.record_steps and self._step_rec_fn:
-            self._step_rec_fn.stop()
-        prev_action = self.current_action
-        self.step_num += 1
-        self.current_action = self.schedule(self.step_num)
-        self.action_controller.transit_action(prev_action, self.current_action)
-        if self.record_steps:
-            self._step_rec_fn = RecordFunction(ProfilerStepNameConstant.PROFILER_STEP + str(self.step_num))
-            self._step_rec_fn.start()
+        self._profiler.step()
 
     def add_metadata(self, key: str, value: str):
         """
@@ -1085,18 +1075,8 @@ class Profile:
             ...     # Call Profiler add_metadata
             ...     prof.add_metadata("test_key", "test_value")
         """
-        if not isinstance(key, str) or not isinstance(value, str):
-            logger.warning("The key and value of metadata must be string. Skip this metadata.")
-            return
 
-        add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
-            if key in self._metadata:
-                logger.warning(f"{key} is already saved as metadata, override it.")
-            self._metadata[key] = value
-            ProfilerMetaData.set_metadata(self._metadata)
-        else:
-            logger.warning("Too many metadata added. Skip this metadata")
+        self._profiler.add_metadata(key, value)
 
     def add_metadata_json(self, key: str, value: str):
         """
@@ -1114,35 +1094,7 @@ class Profile:
             ...     # Call Profiler add_metadata_json
             ...     prof.add_metadata_json("test_key", json.dumps({"key1": 1, "key2": 2}))
         """
-        if not isinstance(key, str) or not isinstance(value, str):
-            logger.warning("The key and value of metadata must be string. Skip this metadata.")
-            return
-
-        add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
-            try:
-                if key in self._metadata:
-                    logger.warning(f"{key} is already saved as metadata, override it.")
-                self._metadata[key] = json.loads(value)
-                ProfilerMetaData.set_metadata(self._metadata)
-            except ValueError:
-                logger.warning("The metadata value must be json format string. Skip this metadata")
-        else:
-            logger.warning("Too many metadata added. Skip this metadata")
-
-    def __enter__(self) -> 'Profile':
-        if not self._has_started:
-            self.start()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        if self._has_started:
-            self.stop()
-
-    def __del__(self):
-        if self._has_started:
-            self.stop()
-            logger.warning("profile is stopped at the end of the program.")
+        self._profiler.add_metadata_json(key, value)
 
 
 def analyse(profiler_path: str, max_process_number: int = os.cpu_count() // 2, pretty=False, step_list=None,

mindspore/profiler/profiler_action_controller.py

@@ -56,7 +56,7 @@ 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.prof_interface)
+            self.on_trace_ready()
 
     def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
         """

mindspore/profiler/profiler_interface.py

@@ -76,14 +76,14 @@ class ProfilerInterface:
         logger.info("ProfilerInterface stop")
 
     @classmethod
-    def analyse(cls, **kwargs):
+    def analyse(cls):
         """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(**kwargs)
+            profiler.analyse()
 
         logger.info("ProfilerInterface analyse")
 

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_node.value)
+            return True, bool(ast.value)
         # Get the module where the code of ast_node is located
         file_path = inspect.getfile(type(self.get_origin_network()))
         module = None

mindspore/runtime/__init__.py

@@ -17,10 +17,9 @@
 The runtime interface.
 """
 
-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,\
-                                 memory_replay, reset_peak_memory_stats, memory_summary, memory_allocated,\
+from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity, set_kernel_launch_group
+from mindspore.runtime.memory import 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
 from mindspore.runtime.stream import Stream, synchronize, set_cur_stream, current_stream, \
     default_stream, communication_stream, StreamCtx
@@ -28,8 +27,7 @@ from mindspore.runtime.event import Event
 from .executor import launch_blocking
 
 __all__ = [
-    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity",
-    "set_kernel_launch_group", "set_kernel_launch_capture",
+    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity", "set_kernel_launch_group",
     "Stream", "communication_stream", "synchronize", "set_cur_stream", "current_stream", "default_stream", "StreamCtx",
     "set_memory", "memory_stats", "memory_reserved", "max_memory_reserved", "empty_cache", "memory_replay",
     "reset_peak_memory_stats", "memory_summary", "memory_allocated", "max_memory_allocated",

mindspore/runtime/executor.py

@@ -179,9 +179,6 @@ def set_kernel_launch_group(thread_num=2, kernel_group_num=8):
     if RuntimeConf.get_instance().is_kernel_launch_group_configured():
         raise RuntimeError("The 'kernel_launch_group' can not be set repeatedly.")
 
-    if RuntimeConf.get_instance().get_enable_kernel_launch_capture():
-        raise RuntimeError("The kernel launch group and kernel launch capture can not be set together")
-
     if thread_num < 1:
         raise ValueError(f"The value of thread_num should be at least 1, but got {thread_num}")
 
@@ -193,27 +190,3 @@ def set_kernel_launch_group(thread_num=2, kernel_group_num=8):
                          f"be evenly divisible by thread_num: {thread_num}")
 
     return RuntimeConf.get_instance().set_kernel_launch_group(thread_num, kernel_group_num)
-
-
-@args_type_check(enable_capture_graph=bool)
-def set_kernel_launch_capture(enable_capture_graph):
-    """
-    In O0/O1 mode, the incremental inference scenario supports graph capture.
-    By capturing the CPU-side operator dispatch behavior into a graph,
-    the performance of CPU-side operator dispatch is improved.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        enable_capture_graph (bool): Whether to enable graph capture.
-            It can be turned on or off at any position in the script.
-
-    Examples:
-        >>> import mindspore as ms
-        >>> ms.runtime.set_kernel_launch_capture(enable_capture_graph=True)
-    """
-    if RuntimeConf.get_instance().is_kernel_launch_group_configured():
-        raise RuntimeError("The kernel launch group and kernel launch capture can not be set together")
-
-    return RuntimeConf.get_instance().set_kernel_launch_capture(enable_capture_graph)

mindspore/runtime/memory.py

@@ -50,7 +50,6 @@ def set_memory(init_size="2GB", increase_size="2GB", max_size="1024GB", optimize
             The format is "xxGB". Default is the maximum available memory of the device, expressed as ``1024GB``.
         optimize_level (str): The memory optimize level. The value must be in ['O0', 'O1']. Default: ``O0`` .
         huge_page_reserve_size (str): The reserved size of huge page memory. The format is "xxGB". Default: ``0GB``.
-            When virtual memory is enabled, reserve huge page function is not available and this parameter is ignored.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/runtime/thread_bind_core.py

@@ -38,7 +38,7 @@ def execute_command(cmd_list):
             out, _ = p.communicate(timeout=1000)
         res = out.decode()
         return res
-    except OSError  as e:
+    except FileNotFoundError as e:
         raise RuntimeError("Failed to execute command") from e
 
 

mindspore/train/_utils.py

@@ -26,7 +26,7 @@ import numpy as np
 from mindspore.common.tensor import Tensor
 from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import MSContext, ms_ctx_param
-from mindspore.common.dtype import _dtype_to_nptype, _pytype_to_dtype
+from mindspore.common.dtype import dtype_to_nptype, pytype_to_dtype
 from mindspore.common import dtype as mstype
 from mindspore import context
 from mindspore import log as logger
@@ -54,7 +54,7 @@ def _convert_type(types):
     """
     ms_types = []
     for np_type in types:
-        ms_type = _pytype_to_dtype(np_type)  # pylint:disable=protected-access
+        ms_type = pytype_to_dtype(np_type)
         ms_types.append(ms_type)
     return ms_types
 
@@ -131,7 +131,7 @@ def _construct_tensor_list(types, shapes, batch_expand_num=1):
                 new_shape += (item * batch_expand_num,)
             else:
                 new_shape += (item,)
-        tensor = Tensor(np.zeros(new_shape, _dtype_to_nptype(type_)), dtype=type_)  # pylint:disable=protected-access
+        tensor = Tensor(np.zeros(new_shape, dtype_to_nptype(type_)), dtype=type_)
         tensor.virtual_flag = True
         tensor_list.append(tensor)
     return tensor_list

mindspore/train/amp.py

@@ -463,6 +463,9 @@ def auto_mixed_precision(network, amp_level="O0", dtype=mstype.float16):
     ``Addcdiv``, ``Addcmul``, ``Cross``, ``_PyboostCrossPrim``, ``Dot``, ``GridSampler2D``, ``GridSampler3D``,
     ``BiasAdd``, ``AddN``, ``Concat``
 
+    For details on automatic mixed precision, refer to
+    `Automatic Mix Precision <https://www.mindspore.cn/tutorials/en/master/beginner/mixed_precision.html>`_ .
+
     Note:
         - Repeatedly calling mixed-precision interfaces, such as `custom_mixed_precision` and `auto_mixed_precision`,
           can result in a larger network hierarchy and slower performance.

mindspore/train/callback/_callback.py

@@ -60,8 +60,7 @@ def _fill_param_into_net(net, parameter_list):
         if np_val.shape == (1,):
             parameter_dict[param_name] = Parameter(np_val, name=param_name)
         elif np_val.shape == ():
-            # pylint:disable=protected-access
-            parameter_dict[param_name] = Parameter(Tensor(np_val.tolist(), mstype._pytype_to_dtype(np_val.dtype)),
+            parameter_dict[param_name] = Parameter(Tensor(np_val.tolist(), mstype.pytype_to_dtype(np_val.dtype)),
                                                    name=param_name)
         else:
             parameter_dict[param_name] = Parameter(Tensor(np_val), name=param_name)