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

msprobe/mindspore/dump/hook_cell/wrap_functional.py

@@ -0,0 +1,91 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# 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 msprobe.mindspore.dump.hook_cell.hook_cell import HOOKCell
+from msprobe.core.common.utils import Const, load_yaml
+
+
+cur_path = os.path.dirname(os.path.realpath(__file__))
+yaml_path = os.path.join(cur_path, "support_wrap_ops.yaml")
+
+
+def load_ops_functions():
+    ops_func = {f: getattr(ms.ops, f) for f in dir(ms.ops)}
+    mint_ops_func = {f: getattr(ms.mint, f) for f in dir(ms.mint)}
+    mint_func_ops_func = {f: getattr(ms.mint.nn.functional, f) for f in dir(ms.mint.nn.functional)}
+    return ops_func, mint_ops_func, mint_func_ops_func
+
+
+def get_functional_ops():
+    ops_func, mint_ops_func, mint_func_ops_func = load_ops_functions()
+    config = load_yaml(yaml_path)
+    wrap_functional = config.get("ops")
+    wrap_mint = config.get("mint.ops")
+    wrap_mint_functional = config.get("mint.nn.functional")
+    return (
+        set(wrap_functional) & set(ops_func.keys()),
+        set(wrap_mint) & set(mint_ops_func.keys()),
+        set(wrap_mint_functional) & set(mint_func_ops_func.keys())
+    )
+
+
+class HOOKFunctionalOP(object):
+    pass
+
+
+class HOOKMintOP(object):
+    pass
+
+
+class HOOKMintNNFunctionalOP(object):
+    pass
+
+
+class FunctionalOPTemplate(HOOKCell):
+    def __init__(self, op_name, op_dict, prefix, hook):
+        self.op_name = op_name
+        self.op_func = op_dict[op_name]
+        self.prefix_op_name_ = prefix + str(op_name.split(Const.SEP)[-1]) + Const.SEP
+        super().__init__(hook)
+
+    def construct(self, *args, **kwargs):
+        if self.op_name.startswith('dropout'):
+            return args[0] if args else kwargs.get('input')
+        return self.op_func(*args, **kwargs)
+
+
+def wrap_functional_op(op_name, op_dict, prefix, hook):
+    def op_template(*args, **kwargs):
+        return FunctionalOPTemplate(op_name, op_dict, prefix, hook)(*args, **kwargs)
+    return op_template
+
+
+def wrap_functional_ops_and_bind(ops, op_dict, prefix, hook, hook_class):
+    for op_name in ops:
+        if callable(op_dict[op_name]):
+            setattr(hook_class, Const.ATTR_NAME_PREFIX + op_name, wrap_functional_op(op_name, op_dict, prefix, hook))
+
+
+def setup_hooks(hook):
+    functional_ops, mint_ops, mint_func_ops = get_functional_ops()
+    wrap_functional_ops_and_bind(
+        functional_ops, {f: getattr(ms.ops, f) for f in dir(ms.ops)}, "Functional.", hook, HOOKFunctionalOP)
+    wrap_functional_ops_and_bind(
+        mint_ops, {f: getattr(ms.mint, f) for f in dir(ms.mint)}, "Mint.", hook, HOOKMintOP)
+    wrap_functional_ops_and_bind(
+        mint_func_ops, {f: getattr(ms.mint.nn.functional, f) for f in dir(ms.mint.nn.functional)}, "MintFunctional.", hook, HOOKMintNNFunctionalOP)
+

msprobe/mindspore/dump/hook_cell/wrap_tensor.py

@@ -0,0 +1,63 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# 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 msprobe.mindspore.dump.hook_cell.hook_cell import HOOKCell
+from msprobe.core.common.utils import Const, load_yaml
+
+
+cur_path = os.path.dirname(os.path.realpath(__file__))
+yaml_path = os.path.join(cur_path, "support_wrap_ops.yaml")
+
+
+TensorFunc = {}
+for f in dir(ms.Tensor):
+    TensorFunc[f] = getattr(ms.Tensor, f)
+
+
+def get_tensor_ops():
+    yaml_data = load_yaml(yaml_path)
+    wrap_tensor_ops = yaml_data.get('tensor')
+    _tensor_ops = dir(ms.Tensor)
+    return set(wrap_tensor_ops) & set(_tensor_ops)
+
+
+class HOOKTensor(object):
+    pass
+
+
+class TensorOPTemplate(HOOKCell):
+
+    def __init__(self, op_name, hook):
+        self.op_name_ = op_name
+        self.prefix_op_name_ = "Tensor." + str(op_name) + Const.SEP
+        super().__init__(hook)
+
+    def construct(self, *args, **kwargs):
+        return TensorFunc[str(self.op_name_)](*args, **kwargs)
+
+
+def wrap_tensor_op(op_name, hook):
+    def tensor_op_template(*args, **kwargs):
+        return TensorOPTemplate(op_name, hook)(*args, **kwargs)
+    return tensor_op_template
+
+
+def wrap_tensor_ops_and_bind(hook):
+    _tensor_ops = get_tensor_ops()
+    for op_name in _tensor_ops:
+        if callable(TensorFunc[op_name]):
+            setattr(HOOKTensor, Const.ATTR_NAME_PREFIX + str(op_name), wrap_tensor_op(op_name, hook))

msprobe/mindspore/dump/jit_dump.py

@@ -0,0 +1,56 @@
+import os
+from mindspore.common.api import _MindsporeFunctionExecutor
+from mindspore._c_expression import PyNativeExecutor_
+from msprobe.mindspore.dump.hook_cell.api_registry import api_register
+from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs
+
+
+def dump_jit(name, in_feat, out_feat, is_forward):
+    pid = os.getpid()
+    ori_args = str(name)
+    index = ori_args.find("<")
+    if index != 0 and index != -1:
+        result = ori_args[0:index]
+    else:
+        result = "JitFunction"
+    if is_forward:
+        name_template = "Jit." + result + ".forward"
+    else:
+        name_template = "Jit." + result + ".backward"
+    JitDump.data_collector.visit_and_clear_overflow_status(name_template)
+    if JitDump.data_collector:
+        module_input_output = ModuleForwardInputsOutputs(args=in_feat, kwargs={}, output=out_feat)
+        JitDump.data_collector.forward_data_collect(name_template, {}, pid, module_input_output)
+
+
+class JitDump(_MindsporeFunctionExecutor):
+    dump_config = None
+    jit_enable = False
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._executor = PyNativeExecutor_.get_instance()
+
+    def __call__(self, *args, **kwargs):
+        api_register.api_set_ori_func()
+        out = super().__call__(*args, **kwargs)
+        dump_jit(args[0], args[1], out, True)
+        JitDump.jit_enable = True
+        api_register.api_set_hook_func()
+        return out
+
+    @classmethod
+    def set_config(cls, value):
+        cls.dump_config = value
+
+    @classmethod
+    def set_data_collector(cls, value):
+        cls.data_collector = value
+
+    def grad(self, obj, grad, weights, grad_position, *args,  **kwargs):
+        if JitDump.jit_enable:
+            api_register.api_set_ori_func()
+        output = self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
+        if JitDump.jit_enable:
+            dump_jit(obj, args, output, False)
+            api_register.api_set_hook_func()
+        return output

msprobe/mindspore/dump/kernel_kbyk_dump.py

@@ -0,0 +1,65 @@
+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
+from msprobe.core.common.const import Const
+
+
+class KernelKbykDump:
+    COMMON_SETTINGS = "common_dump_settings"
+    E2E_SETTINGS = "e2e_dump_settings"
+
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        common_set = dict()
+        e2e_set = dict()
+
+        common_set = dict()
+        common_set["dump_mode"] = 0
+        common_set["path"] = ""
+        common_set["net_name"] = "Net"
+        common_set["iteration"] = "all"
+        common_set["saved_data"] = "statistic"
+        common_set["input_output"] = 0
+        common_set["kernels"] = []
+        common_set["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        e2e_set = dict()
+        e2e_set["enable"] = True
+        e2e_set["trans_flag"] = True
+
+        if config.list:
+            common_set["dump_mode"] = 1
+            common_set["kernels"] = config.list
+        common_set["path"] = config.dump_path
+        if config.step:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            common_set["iteration"] = step_str[:-1]
+        if config.rank:
+            common_set["support_device"] = config.rank
+        if config.task == Const.TENSOR:
+            common_set["saved_data"] = Const.TENSOR
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == Const.INPUT:
+                common_set["input_output"] = 1
+            if config.data_mode[0] == Const.OUTPUT:
+                common_set["input_output"] = 2
+
+        self.dump_json[KernelKbykDump.COMMON_SETTINGS] = common_set
+        self.dump_json[KernelKbykDump.E2E_SETTINGS] = e2e_set
+
+    def handle(self):
+        json_path = self.dump_json[KernelKbykDump.COMMON_SETTINGS]["path"]
+        make_dump_path_if_not_exists(json_path)
+        json_path = os.path.join(json_path, "kernel_kbyk_dump.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/free_benchmark/api_pynative_self_check.py

@@ -0,0 +1,116 @@
+import os
+import inspect
+import importlib
+
+import mindspore as ms
+from mindspore.communication import comm_func
+
+from msprobe.core.common.utils import load_yaml
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.free_benchmark.common.config import Config
+from msprobe.core.common.file_check import check_path_length
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.free_benchmark.decorator.decorator_factory import decorate_forward_function
+
+
+class ApiPyNativeSelFCheck:
+    def __init__(self, config: DebuggerConfig):
+        Config.is_enable = True
+        Config.handler_type = config.handler_type
+        Config.pert_type = config.pert_type
+        Config.stage = config.stage
+        Config.dump_level = config.dump_level
+        Config.steps = config.step
+        Config.ranks = config.rank
+        Config.dump_path = os.path.join(config.dump_path, "free_benchmark.csv")
+        check_path_length(Config.dump_path)
+
+        self.api_list = config.list
+        all_api = get_supported_ops()
+        if not self.api_list:
+            self.api_list = all_api
+        else:
+            self.api_list = set(self.api_list) & all_api
+
+    def handle(self):
+        for api_name in self.api_list:
+            hijack(api_name)
+
+
+def get_supported_ops():
+    supported_ops = []
+    cur_path = os.path.dirname(os.path.realpath(__file__))
+    yaml_path = os.path.join(cur_path, "data", "support_wrap_ops.yaml")
+
+    yaml_data = load_yaml(yaml_path)
+    for k, v in FreeBenchmarkConst.API_PREFIX_DICT.items():
+        ops = yaml_data.get(k)
+        if ops:
+            ops = [v + i for i in ops]
+            supported_ops += ops
+
+    _all_functional_ops = []
+    ms_ops = dir(ms.ops)
+    ms_ops = [FreeBenchmarkConst.OPS_PREFIX + i for i in ms_ops]
+    _all_functional_ops += ms_ops
+
+    ms_tensor = dir(ms.Tensor)
+    ms_tensor = [FreeBenchmarkConst.Tensor_PREFIX + i for i in ms_tensor]
+    _all_functional_ops += ms_tensor
+
+    ms_mint = dir(ms.mint)
+    ms_mint = [FreeBenchmarkConst.MINT_PREFIX + i for i in ms_mint]
+    _all_functional_ops += ms_mint
+
+    ms_mint_nn_func = dir(ms.mint.nn.functional)
+    ms_mint_nn_func = [FreeBenchmarkConst.MINT_NN_FUNC_PREFIX + i for i in ms_mint_nn_func]
+    _all_functional_ops += ms_mint_nn_func
+
+    ms_communication = dir(comm_func)
+    ms_communication = [FreeBenchmarkConst.COMM_PREFIX + i for i in ms_communication]
+    _all_functional_ops += ms_communication
+
+    return set(supported_ops) & set(_all_functional_ops)
+
+
+def get_decorate_func():
+    return decorate_forward_function
+
+
+def is_func_support_decorate(orig_func):
+    return not inspect.isclass(orig_func) and callable(orig_func)
+
+
+def get_wrapper_obj(orig_func, api_name):
+    if is_func_support_decorate(orig_func):
+        wrapped_obj = get_decorate_func()(orig_func, api_name)
+    else:
+        wrapped_obj = orig_func
+    return wrapped_obj
+
+
+def get_module(api_name):
+    func_name_list = api_name.split(Const.SEP)
+    func_name = func_name_list[-1]
+    module_obj = importlib.import_module(func_name_list[0])
+    for i, module_name in enumerate(func_name_list[1:-1]):
+        if not hasattr(module_obj, module_name):
+            importlib.import_module(f"{Const.SEP.join(func_name_list[:i+2])}")
+        module_obj = getattr(module_obj, module_name)
+    orig_func = getattr(module_obj, func_name)
+
+    return module_obj, orig_func
+
+
+def hijack(api_name):
+    if not api_name.strip():
+        return
+    try:
+        func_name = api_name.split(Const.SEP)[-1]
+        module_obj, origin_func = get_module(api_name)
+        wrapped_obj = get_wrapper_obj(origin_func, api_name)
+        setattr(module_obj, func_name, wrapped_obj)
+    except Exception as e:
+        logger.error(f"Failed decorator {api_name}: {e}")

msprobe/mindspore/free_benchmark/common/config.py

@@ -0,0 +1,12 @@
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+
+
+class Config:
+    is_enable: bool = False
+    handler_type = FreeBenchmarkConst.DEFAULT_HANDLER_TYPE
+    pert_type = FreeBenchmarkConst.DEFAULT_PERT_TYPE
+    stage = FreeBenchmarkConst.DEFAULT_STAGE
+    dump_level = FreeBenchmarkConst.DEFAULT_DUMP_LEVEL
+    steps: list = []
+    ranks: list = []
+    dump_path: str = ""

msprobe/mindspore/free_benchmark/common/handler_params.py

@@ -0,0 +1,17 @@
+from typing import Optional, Any, Tuple, Dict, Callable
+
+
+class HandlerParams:
+    """
+    参数结合体
+
+    """
+    args: Optional[Tuple] = None
+    kwargs: Optional[Dict] = None
+    index: Optional[int] = None
+    original_result: Optional[Any] = None
+    fuzzed_result: Optional[Any] = None
+    is_consistent: Optional[bool] = True
+    save_flag: Optional[bool] = True
+    fuzzed_value: Optional[Any] = None
+    original_func: Optional[Callable] = None

msprobe/mindspore/free_benchmark/common/utils.py

@@ -0,0 +1,71 @@
+from typing import Any
+from typing import Optional
+from dataclasses import dataclass
+
+import mindspore as ms
+from mindspore import Tensor
+
+from msprobe.mindspore.runtime import Runtime
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from .config import Config
+from .handler_params import HandlerParams
+
+
+class Tools:
+
+    @staticmethod
+    def get_first_tensor_dtype(tensor_seq: Any):
+        if isinstance(tensor_seq, Tensor):
+            return tensor_seq.dtype
+        if isinstance(tensor_seq, (list, tuple)):
+            for i in tensor_seq:
+                if isinstance(i, Tensor):
+                    return i.dtype
+        raise Exception("The sequence does not contain tensors.")
+
+    @staticmethod
+    def get_default_error_threshold(dtype):
+        if Config.pert_type == FreeBenchmarkConst.NO_CHANGE:
+            return FreeBenchmarkConst.NO_CHANGE_ERROR_THRESHOLD
+        return FreeBenchmarkConst.ERROR_THRESHOLD.get(dtype, FreeBenchmarkConst.ERROR_THRESHOLD.get(ms.float32))
+
+
+@dataclass
+class UnequalRow:
+    rank: Optional[int] = None
+    pert_type: Optional[str] = None
+    stage: Optional[str] = None
+    step: Optional[int] = None
+    api_name: Optional[str] = None
+    max_rel: Optional[float] = None
+    dtype: Optional[str] = None
+    shape: Optional[str] = None
+    output_index: Optional[int] = None
+
+
+def make_unequal_row(
+    api_name: str,
+    params: HandlerParams,
+    ratio: float = None,
+    index: int = None,
+):
+    row = UnequalRow(
+        api_name=api_name,
+        pert_type=Config.pert_type,
+        output_index=index,
+        stage=Config.stage,
+        step=Runtime.step_count
+    )
+    if isinstance(ratio, float):
+        row.max_rel = ratio - 1
+    original_tensor = params.original_result
+    fuzzed_tensor = params.fuzzed_result
+    if index:
+        original_tensor = original_tensor[index]
+        fuzzed_tensor = fuzzed_tensor[index]
+        row.output_index = index
+    if isinstance(original_tensor, Tensor):
+        row.dtype = original_tensor.dtype
+        row.shape = original_tensor.shape
+    row.rank = Runtime.rank_id if Runtime.rank_id != -1 else None
+    return row