mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/mindspore/debugger/debugger_config.py

@@ -1,74 +1,69 @@
-import os
-from pathlib import Path
-
-from msprobe.core.common.const import Const
-from msprobe.mindspore.common.const import Const as MsConst
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.core.common.file_check import FileChecker, FileCheckConst, check_path_before_create
-
-
-class DebuggerConfig:
-    def __init__(self, common_config, task_config):
-        self.execution_mode = None
-        self.dump_path = common_config.dump_path
-        self.task = common_config.task
-        self.rank = [] if not common_config.rank else common_config.rank
-        self.step = [] if not common_config.step else common_config.step
-        common_config.level = Const.LEVEL_L1 if not common_config.level else common_config.level
-        self.level = MsConst.TOOL_LEVEL_DICT.get(common_config.level, MsConst.API)
-        self.level_ori = common_config.level
-        self.list = [] if not task_config.list else task_config.list
-        self.scope = [] if not task_config.scope else task_config.scope
-        self.data_mode = [] if not task_config.data_mode else task_config.data_mode
-        self.file_format = task_config.file_format
-        self.overflow_nums = 1 if not task_config.overflow_nums else task_config.overflow_nums
-        self.check_mode = task_config.check_mode
-        self.framework = Const.MS_FRAMEWORK
-        self.summary_mode = task_config.summary_mode
-        self.check()
-        self._make_dump_path_if_not_exists()
-
-        if self.task == Const.FREE_BENCHMARK:
-            self.pert_type = (FreeBenchmarkConst.DEFAULT_PERT_TYPE
-                              if not task_config.pert_mode else task_config.pert_mode)
-            self.handler_type = (FreeBenchmarkConst.DEFAULT_HANDLER_TYPE
-                                 if not task_config.handler_type else task_config.handler_type)
-            if self.handler_type == FreeBenchmarkConst.FIX_HANDLER_MODE and \
-               self.pert_type != FreeBenchmarkConst.DEFAULT_PERT_TYPE:
-                raise ValueError("pert_mode must be improve_precision or empty when handler_type is fix, "
-                                 f"but got {self.pert_type}.")
-            self.dump_level = FreeBenchmarkConst.DEFAULT_DUMP_LEVEL
-            self.stage = FreeBenchmarkConst.DEFAULT_STAGE
-
-    def check(self):
-        if not self.dump_path:
-            raise Exception("Dump path is empty.")
-        self.dump_path = os.path.abspath(self.dump_path)
-        if not self.task:
-            self.task = "statistics"
-        if not self.level:
-            raise Exception("level must be L0, L1 or L2")
-        if not self.file_format:
-            self.file_format = "npy"
-        if not self.check_mode:
-            self.check_mode = "all"
-        self._check_rank()
-        self._check_step()
-        return True
-
-    def _check_rank(self):
-        for rank_id in self.rank:
-            if not isinstance(rank_id, int) or rank_id < 0:
-                raise ValueError(f"rank {self.rank} must be a positive integer.")
-
-    def _check_step(self):
-        for s in self.step:
-            if not isinstance(s, int) or s < 0:
-                raise ValueError(f"step element {s} must be a positive integer.")
-
-    def _make_dump_path_if_not_exists(self):
-        check_path_before_create(self.dump_path)
-        if not os.path.exists(self.dump_path):
-            Path(self.dump_path).mkdir(mode=FileCheckConst.DATA_DIR_AUTHORITY, exist_ok=True)
-        file_check = FileChecker(self.dump_path, FileCheckConst.DIR)
-        file_check.common_check()
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import os
+
+from msprobe.core.common.const import Const
+from msprobe.core.common.file_utils import create_directory
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+
+
+class DebuggerConfig:
+    def __init__(self, common_config, task_config):
+        self.execution_mode = None
+        self.dump_path = common_config.dump_path
+        self.task = common_config.task
+        self.rank = [] if not common_config.rank else common_config.rank
+        self.step = [] if not common_config.step else common_config.step
+        common_config.level = Const.LEVEL_L1 if not common_config.level else common_config.level
+        self.level = MsConst.TOOL_LEVEL_DICT.get(common_config.level, MsConst.API)
+        self.level_ori = common_config.level
+        self.list = [] if not task_config.list else task_config.list
+        self.scope = [] if not task_config.scope else task_config.scope
+        self.data_mode = [] if not task_config.data_mode else task_config.data_mode
+        self.file_format = task_config.file_format
+        self.overflow_nums = 1 if not task_config.overflow_nums else task_config.overflow_nums
+        self.check_mode = task_config.check_mode
+        self.framework = Const.MS_FRAMEWORK
+        self.summary_mode = task_config.summary_mode
+        self.check()
+        create_directory(self.dump_path)
+
+        if self.task == Const.FREE_BENCHMARK:
+            self.pert_type = (FreeBenchmarkConst.DEFAULT_PERT_TYPE
+                              if not task_config.pert_mode else task_config.pert_mode)
+            self.handler_type = (FreeBenchmarkConst.DEFAULT_HANDLER_TYPE
+                                 if not task_config.handler_type else task_config.handler_type)
+            self.stage = FreeBenchmarkConst.DEFAULT_STAGE if not task_config.fuzz_stage else task_config.fuzz_stage
+            if self.handler_type == FreeBenchmarkConst.FIX and \
+               self.pert_type != FreeBenchmarkConst.DEFAULT_PERT_TYPE:
+                raise ValueError("pert_mode must be improve_precision or empty when handler_type is fix, "
+                                 f"but got {self.pert_type}.")
+            self.dump_level = FreeBenchmarkConst.DEFAULT_DUMP_LEVEL
+
+    def check(self):
+        if not self.dump_path:
+            raise Exception("Dump path is empty.")
+        self.dump_path = os.path.abspath(self.dump_path)
+        if not self.task:
+            self.task = "statistics"
+        if not self.level:
+            raise Exception("level must be L0, L1 or L2")
+        if not self.file_format:
+            self.file_format = "npy"
+        if not self.check_mode:
+            self.check_mode = "all"
+        return True

msprobe/mindspore/debugger/precision_debugger.py

@@ -1,107 +1,150 @@
-import os
-
-import mindspore as ms
-
-from msprobe.mindspore.service import Service
-from msprobe.mindspore.ms_config import parse_json_config
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
-from msprobe.core.common.const import Const
-from msprobe.mindspore.common.const import Const as MsConst
-from msprobe.mindspore.runtime import Runtime
-
-from msprobe.mindspore.grad_probe.grad_monitor import GradientMonitor
-
-
-class PrecisionDebugger:
-    _instance = None
-    task_not_need_service = [Const.GRAD_PROBE]
-
-    def __new__(cls, config_path=None, opt=None):
-        if not cls._instance:
-            cls._instance = super().__new__(cls)
-            cls._instance.initialized = False
-            cls._instance.config = None
-            cls.service = None
-            cls.first_start = False
-        return cls._instance
-
-    def __init__(self, config_path=None):
-        if self.initialized:
-            return
-        self.initialized = True
-        if not config_path:
-            config_path = os.path.join(os.path.dirname(__file__), "../../config/config.json")
-        common_config, task_config = parse_json_config(config_path)
-        self.task = common_config.task
-        if self.task == Const.GRAD_PROBE:
-            self.gm = GradientMonitor(common_config, task_config)
-            return
-        self.config = DebuggerConfig(common_config, task_config)
-
-        Runtime.step_count = 0
-        Runtime.is_running = False
-
-    @staticmethod
-    def _get_execution_mode():
-        if ms.get_context("mode") == ms.GRAPH_MODE:
-            if ms.context.get_jit_config().get("jit_level") == "O2" or ms.get_context("jit_level") == "O2":
-                return MsConst.GRAPH_GE_MODE
-            else:
-                return MsConst.GRAPH_KBYK_MODE
-        else:
-            return MsConst.PYNATIVE_MODE
-
-    @classmethod
-    def start(cls, target=None):
-        instance = cls._instance
-        if not instance:
-            raise Exception("No instance of PrecisionDebugger found.")
-        if instance.task in PrecisionDebugger.task_not_need_service:
-            return
-
-        instance.config.execution_mode = instance._get_execution_mode()
-        if instance.config.execution_mode == MsConst.PYNATIVE_MODE and instance.config.task != Const.FREE_BENCHMARK and instance.config.level != "kernel":
-            if not instance.service:
-                instance.service = Service(instance.config)
-            instance.service.start(target)
-        else:
-            if not instance.first_start:
-                handler = TaskHandlerFactory.create(instance.config)
-                handler.handle()
-
-        instance.first_start = True
-        Runtime.is_running = True
-
-    @classmethod
-    def stop(cls):
-        instance = cls._instance
-        if not instance:
-            raise Exception("PrecisionDebugger instance is not created.")
-        if instance.task == Const.GRAD_PROBE:
-            instance.gm.stop()
-        if instance.task in PrecisionDebugger.task_not_need_service:
-            return
-        if instance.service:
-            instance.service.stop()
-        Runtime.is_running = False
-
-    @classmethod
-    def step(cls):
-        instance = cls._instance
-        if not instance:
-            raise Exception("PrecisionDebugger instance is not created.")
-        if instance.task in PrecisionDebugger.task_not_need_service:
-            return
-        if instance.service:
-            instance.service.step()
-        Runtime.step_count += 1
-
-    @classmethod
-    def monitor(cls, opt):
-        instance = cls._instance
-        if not instance:
-            raise Exception("PrecisionDebugger instance is not created.")
-        if instance.task != Const.GRAD_PROBE:
-            return
-        instance.gm.monitor(opt)
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import os
+
+import mindspore as ms
+from mindspore._c_expression import MSContext
+
+from msprobe.core.common.const import Const, MsgConst
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.grad_probe.grad_monitor import GradientMonitor
+from msprobe.mindspore.ms_config import parse_json_config
+from msprobe.mindspore.runtime import Runtime
+from msprobe.mindspore.service import Service
+from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
+
+
+class PrecisionDebugger:
+    _instance = None
+    task_not_need_service = [Const.GRAD_PROBE]
+
+    def __new__(cls, config_path=None, opt=None):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+            cls._instance.initialized = False
+            cls._instance.config = None
+            cls.service = None
+            cls.first_start = False
+        return cls._instance
+
+    def __init__(self, config_path=None):
+        if self.initialized:
+            return
+        self.initialized = True
+        if not config_path:
+            config_path = os.path.join(os.path.dirname(__file__), "../../config.json")
+        common_config, task_config = parse_json_config(config_path)
+        self.task = common_config.task
+        if self.task == Const.GRAD_PROBE:
+            self.gm = GradientMonitor(common_config, task_config)
+            return
+        self.config = DebuggerConfig(common_config, task_config)
+
+        Runtime.step_count = 0
+        Runtime.is_running = False
+
+    @staticmethod
+    def _get_execution_mode():
+        jit_level = ms.context.get_jit_config().get(MsConst.JIT_LEVEL)
+        jit_level = jit_level if jit_level else ms.get_context(MsConst.JIT_LEVEL)
+        if not jit_level:
+            if MSContext.get_instance().get_ascend_soc_version() == MsConst.ASCEND_910A:
+                jit_level = MsConst.JIT_LEVEL_O2
+            else:
+                jit_level = MsConst.JIT_LEVEL_O0
+
+        if ms.get_context("mode") == ms.GRAPH_MODE:
+            if jit_level == MsConst.JIT_LEVEL_O2:
+                return MsConst.GRAPH_GE_MODE
+            else:
+                return MsConst.GRAPH_KBYK_MODE
+        else:
+            return MsConst.PYNATIVE_MODE
+
+    @classmethod
+    def start(cls, model=None):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+
+        instance.config.execution_mode = cls._get_execution_mode()
+        if cls._need_service():
+            if not instance.service:
+                instance.service = Service(instance.config)
+            instance.service.start(model)
+        else:
+            if not instance.first_start:
+                handler = TaskHandlerFactory.create(instance.config)
+                handler.handle()
+
+        instance.first_start = True
+        Runtime.is_running = True
+
+    @classmethod
+    def forward_backward_dump_end(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+        if instance.service:
+            instance.service.forward_backward_dump_end()
+
+    @classmethod
+    def stop(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task == Const.GRAD_PROBE:
+            instance.gm.stop()
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+        if instance.service:
+            instance.service.stop()
+        Runtime.is_running = False
+
+    @classmethod
+    def step(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+        if instance.service:
+            instance.service.step()
+        Runtime.step_count += 1
+
+    @classmethod
+    def monitor(cls, opt):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task != Const.GRAD_PROBE:
+            return
+        instance.gm.monitor(opt)
+
+    @classmethod
+    def _need_service(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.config.execution_mode != MsConst.PYNATIVE_MODE:
+            return False
+        else:
+            return instance.config.task != Const.FREE_BENCHMARK and instance.config.level != MsConst.KERNEL

msprobe/mindspore/dump/dump_tool_factory.py

@@ -1,35 +1,50 @@
-from msprobe.mindspore.common.const import Const
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.dump.kernel_kbyk_dump import KernelKbykDump
-from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
-
-
-class DumpToolFactory:
-    tools = {
-        Const.CELL: {
-            Const.GRAPH_KBYK_MODE: None,
-            Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: None
-        },
-        Const.API: {
-            Const.GRAPH_KBYK_MODE: None,
-            Const.GRAPH_GE_MODE: None,
-            Const.PYNATIVE_MODE: None
-        },
-        Const.KERNEL: {
-            Const.GRAPH_KBYK_MODE: KernelKbykDump,
-            Const.GRAPH_GE_MODE: KernelGraphDump,
-            Const.PYNATIVE_MODE: KernelKbykDump
-        }
-    }
-
-    @staticmethod
-    def create(config: DebuggerConfig):
-        tool = DumpToolFactory.tools.get(config.level)
-        if not tool:
-            raise Exception("Valid level is needed.")
-        tool = tool.get(config.execution_mode)
-        if not tool:
-            raise Exception(f"Data dump is not supported in {config.execution_mode} mode "
-                            f"when dump level is {config.level}.")
-        return tool(config)
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from msprobe.mindspore.common.const import Const
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
+from msprobe.mindspore.dump.kernel_kbyk_dump import KernelKbykDump
+
+
+class DumpToolFactory:
+    tools = {
+        Const.CELL: {
+            Const.GRAPH_KBYK_MODE: None,
+            Const.GRAPH_GE_MODE: None,
+            Const.PYNATIVE_MODE: None
+        },
+        Const.API: {
+            Const.GRAPH_KBYK_MODE: None,
+            Const.GRAPH_GE_MODE: None,
+            Const.PYNATIVE_MODE: None
+        },
+        Const.KERNEL: {
+            Const.GRAPH_KBYK_MODE: KernelKbykDump,
+            Const.GRAPH_GE_MODE: KernelGraphDump,
+            Const.PYNATIVE_MODE: KernelKbykDump
+        }
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        tool = DumpToolFactory.tools.get(config.level)
+        if not tool:
+            raise Exception("Valid level is needed.")
+        tool = tool.get(config.execution_mode)
+        if not tool:
+            raise Exception(f"Data dump is not supported in {config.execution_mode} mode "
+                            f"when dump level is {config.level}.")
+        return tool(config)