mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/mindspore/grad_probe/hook.py

@@ -1,115 +0,0 @@
-# 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
-import mindspore as ms
-from mindspore.common.api import jit
-from mindspore.common.initializer import initializer
-from mindspore.common.parameter import Parameter
-from mindspore.nn.optim.optimizer import Optimizer
-from msprobe.core.common.file_utils import remove_path, write_csv, create_directory
-from msprobe.core.grad_probe.constant import GradConst
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.grad_probe.global_context import grad_context
-from msprobe.mindspore.grad_probe.grad_analyzer import csv_generator
-from msprobe.mindspore.grad_probe.grad_analyzer import grad_dump, get_rank_id, GradDumpConfig
-from msprobe.mindspore.grad_probe.grad_stat_csv import GradStatCsv, CsvInput
-from msprobe.mindspore.grad_probe.utils import save_grad_direction, get_adapted_level
-
-
-class HookInput:
-    '''
-    HookInput is a class wrapping all the variables used for hooking optimizer
-    '''
-
-    def __init__(self, opt) -> None:
-        self.func = opt.construct
-        if hasattr(opt, "_parameters"):
-            parameter_list = opt._parameters
-        elif hasattr(opt, "parameters"):
-            parameter_list = opt.parameters
-        else:
-            logger.error_log_with_exp("Given optimizer has no attributes: '_parameters' or 'parameters'. \
-                                      Please check the type of the given optimizer.", ValueError)
-        self.g_names = [param.name for param in parameter_list]
-        self.param_list = grad_context.get_context(GradConst.PARAM_LIST)
-        self.rank_id = get_rank_id()
-        output_path = grad_context.get_context(GradConst.OUTPUT_PATH)
-        time_stamp = grad_context.get_context(GradConst.TIME_STAMP)
-        self.dump_dir = os.path.join(output_path, f"rank{self.rank_id}", f"Dump{time_stamp}")
-        self.save_dir = os.path.join(output_path, f"rank{self.rank_id}")
-        self.step_finish_flag = os.path.join(self.dump_dir, GradConst.STEP_FINISH)
-        self.level = grad_context.get_context(GradConst.LEVEL)
-        self.bounds = grad_context.get_context(GradConst.BOUNDS)
-        self.mode = mindspore.get_context("mode")
-
-
-def hook_graph_mode_optimizer(opt, hook_input):
-    @jit
-    def new_construct(self, gradients):
-        for index, grad_value in enumerate(gradients):
-            if hook_input.param_list and hook_input.g_names[index] not in hook_input.param_list:
-                continue
-            conf = GradDumpConfig(dump_dir=hook_input.dump_dir, g_name=hook_input.g_names[index],
-                                  dump_step=self.dump_step, grad=grad_value, level=hook_input.level,
-                                  bounds=hook_input.bounds)
-            grad_dump(conf)
-        ms.ops.TensorDump()(hook_input.step_finish_flag, self.dump_step)
-        self.assignadd(self.dump_step, self.global_step_increase_tensor)
-        out = hook_input.func(gradients)
-        return out
-
-    opt.dump_step = Parameter(initializer(0, [1], ms.int32), name="dump_step")
-    opt.construct = new_construct.__get__(opt, type(opt))
-    csv_generator.start()
-
-
-def hook_pynative_optimizer(opt, hook_input):
-    level_adapted = get_adapted_level(hook_input.level)
-
-    def hook_fn(cell, input_data):
-        gradients, = input_data
-        cur_step = grad_context.get_context(GradConst.CURRENT_STEP)
-        if grad_context.step_need_dump(cur_step) and grad_context.rank_need_dump(hook_input.rank_id):
-            create_directory(hook_input.save_dir)
-            output_lines = []
-            for index, grad_value in enumerate(gradients):
-                param_name = hook_input.g_names[index]
-                if hook_input.param_list and param_name not in hook_input.param_list:
-                    continue
-                csv_input = CsvInput(param_name, grad_value, hook_input.bounds)
-                grad_info = GradStatCsv.get_csv_line(level_adapted, csv_input)
-                output_lines.append(grad_info)
-                if level_adapted["have_grad_direction"]:
-                    save_grad_direction(param_name, grad_value, os.path.join(hook_input.save_dir, f'step{cur_step}'))
-            output_csv_path = os.path.join(hook_input.save_dir, f"grad_summary_{cur_step}.csv")
-            dummy_csv_input = CsvInput(None, None, hook_input.bounds)
-            output_lines.insert(0, GradStatCsv.get_csv_header(level_adapted, dummy_csv_input))
-            write_csv(output_lines, output_csv_path)
-            logger.info(f"write grad data to {output_csv_path}")
-        grad_context.update_step()
-
-    opt.register_forward_pre_hook(hook_fn)
-
-
-def hook_optimizer(opt: Optimizer):
-    hook_input = HookInput(opt)
-
-    if hook_input.mode == mindspore.GRAPH_MODE:
-        hook_graph_mode_optimizer(opt, hook_input)
-    else:
-        hook_pynative_optimizer(opt, hook_input)

msprobe/mindspore/grad_probe/utils.py

@@ -1,43 +0,0 @@
-# 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
-from msprobe.core.common.file_utils import (create_directory,
-                                            check_file_or_directory_path,
-                                            save_npy)
-from msprobe.core.grad_probe.constant import level_adp
-from msprobe.core.grad_probe.utils import check_param
-
-
-def save_grad_direction(param_name, grad, save_path):
-    if not os.path.exists(save_path):
-        create_directory(save_path)
-    check_file_or_directory_path(save_path, isdir=True)
-    check_param(param_name)
-    save_filepath = os.path.join(save_path, f"{param_name}.npy")
-
-    if grad.dtype == mindspore.bfloat16:
-        grad = grad.to(mindspore.float32)
-    grad_direction_tensor = grad > 0
-    grad_direction_ndarray = grad_direction_tensor.numpy()
-
-    save_npy(grad_direction_ndarray, save_filepath)
-
-
-def get_adapted_level(level: str):
-    level_adapted = level_adp.get(level)
-    return level_adapted

msprobe/mindspore/mindtorch/__init__.py

@@ -1,18 +0,0 @@
-# Copyright (c) 2025-2025, 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 .mindtorch_adaptor import (_call_impl,
-                                register_full_backward_pre_hook,
-                                register_full_backward_hook)

msprobe/mindspore/ms_config.py

@@ -1,153 +0,0 @@
-# Copyright (c) 2024-2025, 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.core.common.const import Const
-from msprobe.core.common.utils import is_int
-from msprobe.core.common_config import BaseConfig, CommonConfig
-from msprobe.core.grad_probe.constant import level_adp
-from msprobe.core.grad_probe.utils import check_numeral_list_ascend
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.mindspore.common.log import logger
-
-
-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_summary_mode()
-        self._check_config()
-
-    def _check_config(self):
-        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_summary_mode()
-
-        self.tensor_list = json_config.get("tensor_list", [])
-        self._check_str_list_config(self.tensor_list, "tensor_list")
-        self.stat_cal_mode = json_config.get("device", "host")
-        self.device_stat_precision_mode = json_config.get("precision", "high")
-        self._check_stat_params()
-
-    def _check_stat_params(self):
-        if self.stat_cal_mode not in ["device", "host"]:
-            raise Exception("Config param [device] is invalid, expected from [\"device\", \"host\"]")
-        if self.device_stat_precision_mode not in ["high", "low"]:
-            raise Exception("Config param [precision] is invalid, expected from [\"high\", \"low\"]")
-
-    def _check_summary_mode(self):
-        muti_opt = ["max", "min", "mean", "count", "negative zero count", "positive zero count", "nan count",
-                    "negative inf count", "positive inf count", "zero count", "l2norm", "hash", "md5"]
-        if isinstance(self.summary_mode, str) and self.summary_mode not in Const.SUMMARY_MODE:
-            raise Exception("summary_mode is an invalid string")
-        if isinstance(self.summary_mode, list) and not all(opt in muti_opt for opt in self.summary_mode):
-            raise Exception("summary_mode contains invalid option(s)")
-
-
-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 is_int(self.overflow_nums):
-            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 ExceptionDumpConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.data_mode = ["all"]
-
-
-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, backward 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)
-
-
-class StructureConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-
-
-TaskDict = {
-    Const.TENSOR: TensorConfig,
-    Const.STATISTICS: StatisticsConfig,
-    Const.OVERFLOW_CHECK: OverflowCheckConfig,
-    Const.FREE_BENCHMARK: FreeBenchmarkConfig,
-    Const.GRAD_PROBE: GradProbeConfig,
-    Const.STRUCTURE: StructureConfig,
-    Const.EXCEPTION_DUMP: ExceptionDumpConfig
-}
-
-
-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)

msprobe/mindspore/task_handler_factory.py

@@ -1,44 +0,0 @@
-# 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.core.common.const import Const
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.mindspore.dump.dump_tool_factory import DumpToolFactory
-from msprobe.mindspore.overflow_check.overflow_check_tool_factory import OverflowCheckToolFactory
-from msprobe.mindspore.free_benchmark.self_check_tool_factory import SelfCheckToolFactory
-from msprobe.mindspore.exception_dump.exception_dump_tool_factory import ExceptionDumpToolFactory
-
-
-class TaskHandlerFactory:
-    tasks = {
-        Const.TENSOR: DumpToolFactory,
-        Const.STATISTICS: DumpToolFactory,
-        Const.OVERFLOW_CHECK: OverflowCheckToolFactory,
-        Const.FREE_BENCHMARK: SelfCheckToolFactory,
-        Const.EXCEPTION_DUMP: ExceptionDumpToolFactory
-    }
-
-    @staticmethod
-    def create(config: DebuggerConfig, model=None):
-        task = TaskHandlerFactory.tasks.get(config.task)
-        if not task:
-            raise Exception("Valid task is needed.")
-        if task == DumpToolFactory:
-            handler = task.create(config, model)
-        else:
-            handler = task.create(config)
-        if not handler:
-            raise Exception("Can not find task handler")
-        return handler

msprobe/nan_analyze/__init__.py

@@ -1,14 +0,0 @@
-# Copyright (c) 2025, 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.

msprobe/pytorch/api_accuracy_checker/generate_op_script/config_op.json

@@ -1,9 +0,0 @@
-{
-    "dump_json_path": "./dump.json",
-    "api_name": "",
-    "extract_api_path": "",
-    "propagation": "forward",
-    "data_mode": "random_data",
-    "random_seed": 1234,
-    "iter_times": 1
-}