mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.4__py3-none-any.whl

msprobe/mindspore/ms_config.py

@@ -1,78 +1,128 @@
-import json
-from msprobe.core.common_config import CommonConfig, BaseConfig
-from msprobe.core.common.file_check import FileOpen
-
-
-class TensorConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.check_mode = None
-        self.file_format = json_config.get("file_format")
-        self.check_config()
-        self._check_config()
-
-    def _check_config(self):
-        if self.data_mode is not None and len(self.data_mode) > 0:
-            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
-                raise Exception("data_mode must be all, input or output")
-        if self.file_format and self.file_format not in ["npy", "bin"]:
-            raise Exception("file_format is invalid")
-
-
-class StatisticsConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.file_format = None
-        self.check_mode = None
-        self.check_config()
-        self._check_config()
-
-    def _check_config(self):
-        if self.data_mode is not None and len(self.data_mode) > 0:
-            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
-                raise Exception("data_mode must be all, input or output")
-
-
-class OverflowCheck(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.file_format = None
-        self.check_mode = json_config.get("check_mode")
-        self._check_config()
-
-    def _check_config(self):
-        if self.data_mode is not None and len(self.data_mode) > 0:
-            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
-                raise Exception("data_mode must be all, input or output")
-        if self.check_mode and self.check_mode not in ["all", "aicore", "atomic"]:
-            raise Exception("check_mode is invalid")
-
-
-def parse_common_config(json_config):
-    return CommonConfig(json_config)
-
-
-def parse_task_config(task, json_config):
-    task_map = json_config[task]
-    if not task_map:
-        task_map = dict()
-    if task == "tensor":
-        return TensorConfig(task_map)
-    elif task == "statistics":
-        return StatisticsConfig(task_map)
-    elif task == "overflow_check":
-        return OverflowCheck(task_map)
-    else:
-        raise Exception("task is invalid.")
-
-
-def parse_json_config(json_file_path):
-    if not json_file_path:
-        raise Exception("json file path is None")
-    with FileOpen(json_file_path, 'r') as file:
-        json_config = json.load(file)
-    common_config = parse_common_config(json_config)
-    if not common_config.task:
-        common_config.task = "statistics"
-    task_config = parse_task_config(common_config.task, json_config)
-    return common_config, task_config
+import json
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.core.common.file_utils import FileOpen
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.common.log import logger
+from msprobe.core.grad_probe.constant import level_adp
+from msprobe.core.grad_probe.utils import check_numeral_list_ascend
+
+
+class TensorConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.check_mode = None
+        self.file_format = json_config.get("file_format")
+        self.check_config()
+        self._check_config()
+
+    def _check_config(self):
+        if self.data_mode is not None and len(self.data_mode) > 0:
+            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
+                raise Exception("data_mode must be all, input or output")
+        if self.file_format and self.file_format not in ["npy", "bin"]:
+            raise Exception("file_format is invalid")
+
+
+class StatisticsConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.file_format = None
+        self.check_mode = None
+        self.check_config()
+        self._check_config()
+
+    def _check_config(self):
+        if self.data_mode is not None and len(self.data_mode) > 0:
+            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
+                raise Exception("data_mode must be all, input or output")
+        if self.summary_mode and self.summary_mode not in ["statistics", "md5"]:
+            raise Exception("summary_mode is invalid")
+
+
+class OverflowCheckConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.data_mode = ["all"]
+        self._check_config()
+
+    def _check_config(self):
+        if self.overflow_nums is not None and not isinstance(self.overflow_nums, int):
+            raise Exception("overflow_nums is invalid, it should be an integer")
+        if self.overflow_nums is not None and self.overflow_nums != -1 and self.overflow_nums <= 0:
+            raise Exception("overflow_nums should be -1 or positive integer")
+        if self.check_mode and self.check_mode not in ["all", "aicore", "atomic"]:
+            raise Exception("check_mode is invalid")
+
+
+class FreeBenchmarkConfig(BaseConfig):
+    def __init__(self, task_config):
+        super().__init__(task_config)
+        self._check_config()
+
+    def _check_config(self):
+        if self.fuzz_device and self.fuzz_device not in FreeBenchmarkConst.DEVICE_LIST:
+            raise Exception("fuzz_device must be npu or empty")
+        if self.pert_mode and self.pert_mode not in FreeBenchmarkConst.PERT_TYPE_LIST:
+            raise Exception("pert_mode must be improve_precision, add_noise, bit_noise, "
+                            "no_change, change_value or empty")
+        if self.handler_type and self.handler_type not in FreeBenchmarkConst.HANDLER_TYPE_LIST:
+            raise Exception("handler_type must be check, fix or empty")
+        if self.fuzz_level and self.fuzz_level not in FreeBenchmarkConst.DUMP_LEVEL_LIST:
+            raise Exception("fuzz_level must be L1 or empty")
+        if self.fuzz_stage and self.fuzz_stage not in FreeBenchmarkConst.STAGE_LIST:
+            raise Exception("fuzz_stage must be forward or empty")
+        if self.if_preheat or self.preheat_step or self.max_sample:
+            logger.warning("'if_preheat', 'preheat_step' and 'max_sample' settings "
+                           "are not supported for mindspore free benchmark task.")
+
+
+class GradProbeConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.grad_level = json_config.get("grad_level", "L1")
+        self.param_list = json_config.get("param_list", [])
+        self.bounds = json_config.get("bounds", [-1, 0, 1])
+        self._check_config()
+
+    def _check_config(self):
+        if self.grad_level not in level_adp.keys():
+            raise Exception(f"grad_level must be one of {level_adp.keys()}")
+        if not isinstance(self.param_list, list):
+            raise Exception("param_list must be a list")
+        check_numeral_list_ascend(self.bounds)
+
+
+TaskDict = {
+    Const.TENSOR: TensorConfig,
+    Const.STATISTICS: StatisticsConfig,
+    Const.OVERFLOW_CHECK: OverflowCheckConfig,
+    Const.FREE_BENCHMARK: FreeBenchmarkConfig,
+    Const.GRAD_PROBE: GradProbeConfig
+}
+
+
+def parse_common_config(json_config):
+    return CommonConfig(json_config)
+
+
+def parse_task_config(task, json_config):
+    task_map = json_config.get(task)
+    if not task_map:
+        task_map = dict()
+    if task not in TaskDict:
+        raise Exception("task is invalid.")
+    return TaskDict.get(task)(task_map)
+
+
+def parse_json_config(json_file_path):
+    if not json_file_path:
+        raise Exception("json file path is None")
+    with FileOpen(json_file_path, 'r') as file:
+        json_config = json.load(file)
+    common_config = parse_common_config(json_config)
+    if not common_config.task:
+        common_config.task = Const.STATISTICS
+    task_config = parse_task_config(common_config.task, json_config)
+    return common_config, task_config

msprobe/mindspore/overflow_check/kernel_graph_overflow_check.py

@@ -1,45 +1,44 @@
-import os
-import json
-from msprobe.core.common.utils import make_dump_path_if_not_exists
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.core.common.log import logger
-from msprobe.core.common.file_check import FileOpen
-
-
-class KernelGraphOverflowCheck:
-    def __init__(self, config: DebuggerConfig):
-        self.dump_json = dict()
-        self.dump_json["common_dump_settings"] = dict()
-        self.dump_json["common_dump_settings"]["dump_mode"] = 0
-        self.dump_json["common_dump_settings"]["path"] = ""
-        self.dump_json["common_dump_settings"]["net_name"] = "Net"
-        self.dump_json["common_dump_settings"]["iteration"] = "all"
-        self.dump_json["common_dump_settings"]["saved_data"] = "full"
-        self.dump_json["common_dump_settings"]["input_output"] = 0
-        self.dump_json["common_dump_settings"]["kernels"] = []
-        self.dump_json["common_dump_settings"]["support_device"] = [0,1,2,3,4,5,6,7]
-        self.dump_json["common_dump_settings"]["op_debug_mode"] = 3
-        self.dump_json["common_dump_settings"]["file_format"] = "npy"
-
-        self.dump_json["common_dump_settings"]["path"] = config.dump_path
-        if len(config.step) > 0:
-            logger.warning("Step would change to all in this task.")
-        if len(config.rank) > 0:
-            self.dump_json["common_dump_settings"]["support_device"] = config.rank
-        if config.check_mode == "aicore":
-            self.dump_json["common_dump_settings"]["op_debug_mode"] = 1
-        elif config.check_mode == "atomic":
-            self.dump_json["common_dump_settings"]["op_debug_mode"] = 2
-
-    def handle(self):
-        if os.getenv("GRAPH_OP_RUN") == "1":
-            raise Exception("Must run in graph mode, not kbk mode")
-        json_path = self.dump_json["common_dump_settings"]["path"]
-        make_dump_path_if_not_exists(json_path)
-        json_path = os.path.join(json_path, "kernel_graph_overflow_check.json")
-        with FileOpen(json_path, 'w') as f:
-            json.dump(self.dump_json, f)
-        logger.info(json_path + " has been created.")
-        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
-        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
-            del os.environ["MS_ACL_DUMP_CFG_PATH"]
+import os
+import json
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.file_utils import FileOpen, create_directory
+
+
+class KernelGraphOverflowCheck:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "full"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0,1,2,3,4,5,6,7]
+        self.dump_json["common_dump_settings"]["op_debug_mode"] = 3
+        self.dump_json["common_dump_settings"]["file_format"] = "npy"
+
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            logger.warning("Step would change to all in this task.")
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.check_mode == "aicore":
+            self.dump_json["common_dump_settings"]["op_debug_mode"] = 1
+        elif config.check_mode == "atomic":
+            self.dump_json["common_dump_settings"]["op_debug_mode"] = 2
+
+    def handle(self):
+        if os.getenv("GRAPH_OP_RUN") == "1":
+            raise Exception("Must run in graph mode, not kbk mode")
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        create_directory(json_path)
+        json_path = os.path.join(json_path, "kernel_graph_overflow_check.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/overflow_check/overflow_check_tool_factory.py

@@ -1,32 +1,34 @@
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.overflow_check.kernel_graph_overflow_check import KernelGraphOverflowCheck
-
-
-class OverflowCheckToolFactory:
-    tools = {
-        "cell": {
-            "kbk": None,
-            "graph": None,
-            "pynative": None
-        },
-        "api": {
-            "kbk": None,
-            "graph": None,
-            "pynative": None
-        },
-        "kernel": {
-            "kbk": None,
-            "graph": KernelGraphOverflowCheck,
-            "pynative": None
-        }
-    }
-
-    @staticmethod
-    def create(config: DebuggerConfig):
-        tool = OverflowCheckToolFactory.tools.get(config.level)
-        if not tool:
-            raise Exception("valid level is needed.")
-        tool = tool.get("graph")
-        if not tool:
-            raise Exception("Overflow check in not supported in this mode.")
-        return tool(config)
+from msprobe.mindspore.common.const import Const
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.overflow_check.kernel_graph_overflow_check import KernelGraphOverflowCheck
+
+
+class OverflowCheckToolFactory:
+    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: None,
+            Const.GRAPH_GE_MODE: KernelGraphOverflowCheck,
+            Const.PYNATIVE_MODE: None
+        }
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        tool = OverflowCheckToolFactory.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"Overflow check is not supported in {config.execution_mode} mode "
+                            f"when level is {config.level}.")
+        return tool(config)

msprobe/mindspore/runtime.py

@@ -0,0 +1,4 @@
+class Runtime:
+    step_count: int = 0
+    rank_id: int = -1
+    is_running: bool = False