mindstudio-probe 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

msprobe/visualization/graph/graph.py

@@ -20,9 +20,6 @@ from msprobe.core.common.log import logger
 from msprobe.core.common.const import Const
 
 
-MAX_RECUR_LEVEL = 100
-
-
 class Graph:
     def __init__(self, model_name, data_path='', dump_data=None):
         self.node_map = {}
@@ -67,7 +64,6 @@ class Graph:
         ancestors_b = node_b.get_ancestors()
         return node_b, ancestors_n, ancestors_b
 
-
     @staticmethod
     def fuzzy_match(node_n, node_b):
         if not node_n or not node_b or not node_n.fuzzy_eq(node_b):
@@ -76,13 +72,6 @@ class Graph:
         ancestors_b = node_b.get_ancestors()
         return node_b, ancestors_n, ancestors_b
 
-    @staticmethod
-    def dfs(node, result):
-        info = node.to_dict()
-        result[node.id] = info
-        for subnode in node.subnodes:
-            Graph.dfs(subnode, result)
-
     @staticmethod
     def split_nodes_by_micro_step(nodes):
         """

msprobe/visualization/graph/node_op.py

@@ -24,7 +24,6 @@ class NodeOp(Enum):
     function_api = 1
     api_collection = 9
 
-
     @staticmethod
     def get_node_op(node_name: str):
         """
@@ -37,5 +36,5 @@ class NodeOp(Enum):
             pattern = op_patterns[index]
             if re.match(pattern, node_name):
                 return op
-        logger.warning(f"Cannot parsing node_name {node_name} into NodeOp, default parsing as module.")
+        logger.warning(f"Cannot parse node_name {node_name} into NodeOp, default parsing as module.")
         return NodeOp.module

msprobe/visualization/graph_service.py

@@ -159,7 +159,7 @@ def _compare_graph_steps(input_param, args):
     bench_steps = sorted(check_and_return_dir_contents(dump_step_b, Const.STEP))
 
     if npu_steps != bench_steps:
-        logger.error('The number of steps in the two runs are different. Unable to match the steps.')
+        logger.error('The number of steps in the two runs is different. Unable to match the steps.')
         raise CompareException(CompareException.INVALID_PATH_ERROR)
 
     for folder_step in npu_steps:

msprobe/visualization/utils.py

@@ -42,14 +42,6 @@ def load_data_json_file(file_path):
     return load_json_file(file_path).get(GraphConst.DATA_KEY, {})
 
 
-def save_json_file(file_path, data):
-    """
-    保存json文件
-    """
-    with FileOpen(file_path, 'w') as f:
-        f.write(json.dumps(data, indent=4))
-
-
 def get_csv_df(stack_mode, csv_data, compare_mode):
     """
     调用acc接口写入csv
@@ -73,14 +65,6 @@ def str2float(percentage_str):
         return 0
 
 
-def is_integer(s):
-    try:
-        int(s)
-        return True
-    except Exception:
-        return False
-
-
 def check_directory_content(input_path):
     """
     检查input_path内容, 是否全是step{数字}命名的文件夹(例如step0), 或者全是rank{数字}命名的文件夹(例如rank0), 或者全是文件
@@ -143,14 +127,12 @@ class ToolTip:
         '当最大相对误差越接近0表示其计算的误差越小。'
         '当dump数据中存在0或Nan时，比对结果中最大相对误差则出现inf或Nan的情况，属于正常现象'
     )
-    SMALL_VALUE_TIP = '{}, 由于{}小于{}, 建议不参考此相对误差，请参考绝对误差'
 
 
 class GraphConst:
     CONSTRUCT_FILE = 'construct.json'
     DUMP_FILE = 'dump.json'
     STACK_FILE = 'stack.json'
-    GRAPH_FILE = 'graph.vis'
     ERROR_KEY = 'error_key'
     SUMMARY_COMPARE = 0
     MD5_COMPARE = 1
@@ -164,35 +146,22 @@ class GraphConst:
     JSON_DATA_KEY = 'dump_data_dir'
     JSON_TASK_KEY = 'task'
     DATA_KEY = 'data'
-    REAL_DATA_TH = 0.1
-    MAX_RELATIVE_ERR_TH = 0.5
     ROUND_TH = 6
     JSON_INDEX_KEY = 'precision_index'
     MATCHED_DISTRIBUTED = 'matched_distributed'
     OVERFLOW_LEVEL = 'overflow_level'
     MAX_INDEX_KEY = 1
     MIN_INDEX_KEY = 0
-    SUGGEST_KEY = 'text'
-    TAG_NA = 'na'
-    OUTPUT_INDEX_TWO = -2
-    OUTPUT_INDEX_THREE = -3
-    OUTPUT_MIN_LEN = 3
     INPUT = '.input.'
     OUTPUT = '.output.'
     STR_MAX_LEN = 50
-    SMALL_VALUE = 1e-3
     MD5_INDEX_LIST = [CompareConst.RESULT]
-    REAL_DATA_INDEX_LIST = [CompareConst.COSINE, CompareConst.MAX_ABS_ERR, CompareConst.MAX_RELATIVE_ERR,
-                            CompareConst.ONE_THOUSANDTH_ERR_RATIO, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO]
-    SUMMARY_INDEX_LIST = [CompareConst.MAX_DIFF, CompareConst.MIN_DIFF, CompareConst.MEAN_DIFF,
-                          CompareConst.NORM_DIFF, CompareConst.MAX_RELATIVE_ERR, CompareConst.MIN_RELATIVE_ERR,
-                          CompareConst.MEAN_RELATIVE_ERR, CompareConst.NORM_RELATIVE_ERR]
-    VALUE_INDEX_LIST = [Const.MAX, Const.MIN, Const.MEAN, Const.NORM]
+    REAL_DATA_INDEX_LIST = CompareConst.ALL_COMPARE_INDEX
+    SUMMARY_INDEX_LIST = CompareConst.SUMMARY_COMPARE_INDEX
     APIS_BETWEEN_MODULES = 'Apis_Between_Modules'
     NULL = 'null'
     NONE = 'None'
     VALUE = 'value'
-    BRACE = '{}'
     DESCRIPTION = 'description'
     COLORS = 'Colors'
     MICRO_STEPS = 'MicroSteps'

msprobe/mindspore/dump/hook_cell/api_registry.py

@@ -1,207 +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 mindspore import Tensor, ops, mint
-from mindspore.mint.nn import functional
-from mindspore.common._stub_tensor import StubTensor
-from mindspore.communication import comm_func
-
-from msprobe.mindspore.dump.hook_cell.wrap_api import (HOOKTensor, HOOKStubTensor, HOOKFunctionalOP,
-                                                       HOOKMintOP, HOOKMintNNFunctionalOP, HOOKDistributedOP,
-                                                       HOOKTorchOP, HOOKTorchTensor, HOOKTorchFunctionalOP,
-                                                       HOOKTorchDistributedOP, HOOKTorchNpuOP,
-                                                       get_wrap_api_list, get_wrap_torch_api_list, setup_hooks)
-from msprobe.core.common.utils import Const
-from msprobe.mindspore.common.utils import is_mindtorch
-
-if is_mindtorch():
-    import torch
-    import torch_npu
-
-
-def stub_method(method):
-    def wrapped_method(*args, **kwargs):
-        return method(*args, **kwargs)
-    return wrapped_method
-
-
-class ApiRegistry:
-    def __init__(self):
-        self.tensor_ori_attr = {}
-        self.stub_tensor_ori_attr = {}
-        self.functional_ori_attr = {}
-        self.mint_ops_ori_attr = {}
-        self.mint_func_ops_ori_attr = {}
-        self.distributed_ori_attr = {}
-        self.norm_inner_ops_ori_attr = {}
-
-        self.torch_ori_attr = {}
-        self.torch_tensor_ori_attr = {}
-        self.torch_functional_ori_attr = {}
-        self.torch_distributed_ori_attr = {}
-        self.torch_npu_ori_attr = {}
-
-        self.tensor_hook_attr = {}
-        self.stub_tensor_hook_attr = {}
-        self.functional_hook_attr = {}
-        self.mint_ops_hook_attr = {}
-        self.mint_func_ops_hook_attr = {}
-        self.distibuted_hook_attr = {}
-        self.norm_inner_ops_hook_attr = {}
-
-        self.torch_hook_attr = {}
-        self.torch_tensor_hook_attr = {}
-        self.torch_functional_hook_attr = {}
-        self.torch_distributed_hook_attr = {}
-        self.torch_npu_hook_attr = {}
-
-        self.norm_inner_ops = ["norm", "square", "sqrt", "is_complex"]
-
-    @staticmethod
-    def store_ori_attr(ori_api_group, api_list, api_ori_attr):
-        for api in api_list:
-            if Const.SEP in api:
-                sub_module_name, sub_op = api.rsplit(Const.SEP, 1)
-                sub_module = getattr(ori_api_group, sub_module_name)
-                ori_api_func = getattr(sub_module, sub_op)
-            else:
-                ori_api_func = getattr(ori_api_group, api)
-            if ori_api_group == StubTensor:
-                api_ori_attr[api] = stub_method(ori_api_func)
-                continue
-            api_ori_attr[api] = ori_api_func
-
-    @staticmethod
-    def set_api_attr(api_group, attr_dict):
-        for api, api_attr in attr_dict.items():
-            if Const.SEP in api:
-                sub_module_name, sub_op = api.rsplit(Const.SEP, 1)
-                sub_module = getattr(api_group, sub_module_name, None)
-                if sub_module is not None:
-                    setattr(sub_module, sub_op, api_attr)
-            else:
-                setattr(api_group, api, api_attr)
-
-    def norm_inner_op_set_hook_func(self):
-        self.set_api_attr(ops, self.norm_inner_ops_hook_attr)
-
-    def norm_inner_op_set_ori_func(self):
-        self.set_api_attr(ops, self.norm_inner_ops_ori_attr)
-
-    def api_set_hook_func(self):
-        if is_mindtorch():
-            self.set_api_attr(torch, self.torch_hook_attr)
-            self.set_api_attr(torch.Tensor, self.torch_tensor_hook_attr)
-            self.set_api_attr(torch.nn.functional, self.torch_functional_hook_attr)
-            self.set_api_attr(torch.distributed, self.torch_distributed_hook_attr)
-            self.set_api_attr(torch.distributed.distributed_c10d, self.torch_distributed_hook_attr)
-            self.set_api_attr(torch_npu, self.torch_npu_hook_attr)
-        else:
-            self.set_api_attr(Tensor, self.tensor_hook_attr)
-            self.set_api_attr(StubTensor, self.stub_tensor_hook_attr)
-            self.set_api_attr(ops, self.functional_hook_attr)
-            self.set_api_attr(mint, self.mint_ops_hook_attr)
-            self.set_api_attr(functional, self.mint_func_ops_hook_attr)
-            self.set_api_attr(comm_func, self.distibuted_hook_attr)
-
-    def api_set_ori_func(self):
-        if is_mindtorch():
-            self.set_api_attr(torch, self.torch_ori_attr)
-            self.set_api_attr(torch.Tensor, self.torch_tensor_ori_attr)
-            self.set_api_attr(torch.nn.functional, self.torch_functional_ori_attr)
-            self.set_api_attr(torch.distributed, self.torch_distributed_ori_attr)
-            self.set_api_attr(torch.distributed.distributed_c10d, self.torch_distributed_ori_attr)
-            self.set_api_attr(torch_npu, self.torch_npu_ori_attr)
-        else:
-            self.set_api_attr(Tensor, self.tensor_ori_attr)
-            self.set_api_attr(StubTensor, self.stub_tensor_ori_attr)
-            self.set_api_attr(ops, self.functional_ori_attr)
-            self.set_api_attr(mint, self.mint_ops_ori_attr)
-            self.set_api_attr(functional, self.mint_func_ops_ori_attr)
-            self.set_api_attr(comm_func, self.distributed_ori_attr)
-
-    def initialize_hook(self, hook):
-        setup_hooks(hook)
-        if is_mindtorch():
-            wrap_torch_api_name = get_wrap_torch_api_list()
-            self.store_ori_attr(torch,
-                                wrap_torch_api_name.torch_api_names, self.torch_ori_attr)
-            self.store_ori_attr(torch.Tensor,
-                                wrap_torch_api_name.tensor_api_names, self.torch_tensor_ori_attr)
-            self.store_ori_attr(torch.nn.functional,
-                                wrap_torch_api_name.functional_api_names, self.torch_functional_ori_attr)
-            self.store_ori_attr(torch.distributed,
-                                wrap_torch_api_name.distributed_api_names, self.torch_distributed_ori_attr)
-            self.store_ori_attr(torch_npu,
-                                wrap_torch_api_name.npu_api_names, self.torch_npu_ori_attr)
-            for attr_name in dir(HOOKTorchOP):
-                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                    api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                    self.torch_hook_attr[api_name] = getattr(HOOKTorchOP, attr_name)
-            for attr_name in dir(HOOKTorchTensor):
-                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                    api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                    self.torch_tensor_hook_attr[api_name] = getattr(HOOKTorchTensor, attr_name)
-            for attr_name in dir(HOOKTorchFunctionalOP):
-                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                    api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                    self.torch_functional_hook_attr[api_name] = getattr(HOOKTorchFunctionalOP, attr_name)
-            for attr_name in dir(HOOKTorchDistributedOP):
-                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                    api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                    self.torch_distributed_hook_attr[api_name] = getattr(HOOKTorchDistributedOP, attr_name)
-            for attr_name in dir(HOOKTorchNpuOP):
-                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                    api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                    self.torch_npu_hook_attr[api_name] = getattr(HOOKTorchNpuOP, attr_name)
-            return
-
-        wrap_api_name = get_wrap_api_list()
-        self.store_ori_attr(Tensor, wrap_api_name.tensor_api_names, self.tensor_ori_attr)
-        self.store_ori_attr(StubTensor, wrap_api_name.stub_tensor_api_names, self.stub_tensor_ori_attr)
-        self.store_ori_attr(ops, wrap_api_name.ops_api_names, self.functional_ori_attr)
-        self.store_ori_attr(mint, wrap_api_name.mint_api_names, self.mint_ops_ori_attr)
-        self.store_ori_attr(functional, wrap_api_name.mint_nn_func_api_names, self.mint_func_ops_ori_attr)
-        self.store_ori_attr(comm_func, wrap_api_name.distributed_api_names, self.distributed_ori_attr)
-        self.store_ori_attr(ops, self.norm_inner_ops, self.norm_inner_ops_ori_attr)
-        for attr_name in dir(HOOKTensor):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.tensor_hook_attr[api_name] = getattr(HOOKTensor, attr_name)
-        for attr_name in dir(HOOKStubTensor):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.stub_tensor_hook_attr[api_name] = getattr(HOOKStubTensor, attr_name)
-        for attr_name in dir(HOOKFunctionalOP):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.functional_hook_attr[api_name] = getattr(HOOKFunctionalOP, attr_name)
-                if api_name in self.norm_inner_ops:
-                    self.norm_inner_ops_hook_attr[api_name] = getattr(HOOKFunctionalOP, attr_name)
-        for attr_name in dir(HOOKMintOP):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.mint_ops_hook_attr[api_name] = getattr(HOOKMintOP, attr_name)
-        for attr_name in dir(HOOKMintNNFunctionalOP):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.mint_func_ops_hook_attr[api_name] = getattr(HOOKMintNNFunctionalOP, attr_name)
-        for attr_name in dir(HOOKDistributedOP):
-            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
-                api_name = attr_name[Const.ATTR_NAME_PREFIX_LEN:]
-                self.distibuted_hook_attr[api_name] = getattr(HOOKDistributedOP, attr_name)
-
-
-api_register = ApiRegistry()

msprobe/mindspore/dump/hook_cell/wrap_api.py

@@ -1,212 +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.
-
-import os
-
-from mindspore import Tensor, mint, ops
-from mindspore.common._stub_tensor import StubTensor
-from mindspore.communication import comm_func
-from mindspore.mint.nn import functional
-
-from msprobe.core.common.const import Const
-from msprobe.core.common.file_utils import load_yaml
-from msprobe.mindspore.common.const import Const as MsConst
-from msprobe.mindspore.common.utils import is_mindtorch
-from msprobe.mindspore.dump.hook_cell.hook_cell import HOOKCell
-
-if is_mindtorch():
-    import torch
-    import torch_npu
-
-cur_path = os.path.dirname(os.path.realpath(__file__))
-yaml_path = os.path.join(cur_path, MsConst.SUPPORTED_API_LIST_FILE)
-torch_yaml_path = os.path.join(cur_path, "../../../pytorch/hook_module", MsConst.SUPPORTED_API_LIST_FILE)
-
-
-class HOOKTensor(object):
-    pass
-
-
-class HOOKStubTensor(object):
-    pass
-
-
-class HOOKFunctionalOP(object):
-    pass
-
-
-class HOOKMintOP(object):
-    pass
-
-
-class HOOKMintNNFunctionalOP(object):
-    pass
-
-
-class HOOKDistributedOP(object):
-    pass
-
-
-class HOOKTorchOP(object):
-    pass
-
-
-class HOOKTorchTensor(object):
-    pass
-
-
-class HOOKTorchFunctionalOP(object):
-    pass
-
-
-class HOOKTorchDistributedOP(object):
-    pass
-
-
-class HOOKTorchNpuOP(object):
-    pass
-
-
-class ApiTemplate(HOOKCell):
-    def __init__(self, api_name, api_dict, prefix, hook):
-        self.api_name = api_name
-        self.api_func = api_dict[api_name]
-        self.prefix_api_name = prefix + str(api_name.split(Const.SEP)[-1]) + Const.SEP
-        super().__init__(hook)
-
-    @staticmethod
-    def async_to_sync(output):
-        # Fake handle, used to return after the CommHandle executes the wait method
-        fake_handle = type("FakeHandle", (), {"wait": lambda self: None})()
-        if isinstance(output, tuple) and len(output) == 2 and hasattr(output[1], "wait"):
-            output[1].wait()
-            output = (output[0], fake_handle)
-        elif hasattr(output, "wait"):
-            output.wait()
-            output = fake_handle
-        return output
-
-    def construct(self, *args, **kwargs):
-        if self.api_name.startswith(MsConst.DROPOUT_API_NAME_PREFIX):
-            return args[0] if args else kwargs.get(Const.INPUT)
-        
-        output = self.api_func(*args, **kwargs)
-
-        if self.prefix_api_name.startswith(MsConst.DISTRIBUTED_DATA_PREFIX):
-            if kwargs.get("async_op") or self.api_name in ["isend", "irecv"]:
-                output = self.async_to_sync(output)
-        return output
-
-    def forward(self, *args, **kwargs):
-        if self.api_name.startswith(MsConst.DROPOUT_API_NAME_PREFIX):
-            return args[0] if args else kwargs.get(Const.INPUT)
-        return self.api_func(*args, **kwargs)
-
-
-class WrapApiName:
-    def __init__(self, tensor_api_names, stub_tensor_api_names, ops_api_names, mint_api_names, mint_nn_func_api_names,
-                 distributed_api_names):
-        self.tensor_api_names = tensor_api_names
-        self.stub_tensor_api_names = stub_tensor_api_names
-        self.ops_api_names = ops_api_names
-        self.mint_api_names = mint_api_names
-        self.mint_nn_func_api_names = mint_nn_func_api_names
-        self.distributed_api_names = distributed_api_names
-
-
-class WrapTorchApiName:
-    def __init__(self, torch_api_names, tensor_api_names, functional_api_names, distributed_api_names, npu_api_names):
-        self.torch_api_names = torch_api_names
-        self.tensor_api_names = tensor_api_names
-        self.functional_api_names = functional_api_names
-        self.distributed_api_names = distributed_api_names
-        self.npu_api_names = npu_api_names
-
-
-def get_wrap_api_list():
-    api_list = load_yaml(yaml_path)
-    tensor_api = api_list.get(MsConst.SUPPORTED_TENSOR_LIST_KEY)
-    ops_api = api_list.get(MsConst.SUPPORTED_OPS_LIST_KEY)
-    mint_api = api_list.get(MsConst.SUPPORTED_MINT_LIST_KEY)
-    mint_nn_func_api = api_list.get(MsConst.SUPPORTED__MINT_NN_FUNC_LIST_KEY)
-    distributed_api = api_list.get(MsConst.SUPPORTED_COMM_LIST_KEY)
-    wrap_api_name = WrapApiName(set(tensor_api) & set(dir(Tensor)),
-                                set(tensor_api) & set(dir(StubTensor)),
-                                set(ops_api) & set(dir(ops)),
-                                set(mint_api) & set(dir(mint)),
-                                set(mint_nn_func_api) & set(dir(functional)),
-                                set(distributed_api) & set(dir(comm_func)))
-    return wrap_api_name
-
-
-def get_wrap_torch_api_list():
-    api_list = load_yaml(torch_yaml_path)
-    torch_api = api_list.get("torch")
-    tensor_api = api_list.get("tensor")
-    functional_api = api_list.get("functional")
-    distributed_api = api_list.get("distributed")
-    npu_api = api_list.get("torch_npu")
-    wrap_api_name = WrapTorchApiName(set(torch_api) & set(dir(torch)),
-                                     set(tensor_api) & set(dir(torch.Tensor)),
-                                     set(functional_api) & set(dir(torch.nn.functional)),
-                                     set(distributed_api) & set(dir(torch.distributed)),
-                                     set(npu_api) & set(dir(torch_npu)))
-    return wrap_api_name
-
-
-def wrap_api_func(api_name, api_dict, prefix, hook):
-    def api_function(*args, **kwargs):
-        return ApiTemplate(api_name, api_dict, prefix, hook)(*args, **kwargs)
-    return api_function
-
-
-def wrap_api_func_and_bind(api_list, api_dict, prefix, hook, hook_class):
-    for api_name in api_list:
-        if callable(api_dict[api_name]):
-            setattr(hook_class, Const.ATTR_NAME_PREFIX + api_name, wrap_api_func(api_name, api_dict, prefix, hook))
-
-
-def setup_hooks(hook):
-    if is_mindtorch():
-        torch_wrap_api_name = get_wrap_torch_api_list()
-        wrap_api_func_and_bind(torch_wrap_api_name.torch_api_names,
-                               {f: getattr(torch, f) for f in dir(torch)},
-                               MsConst.TORCH_DATA_PREFIX, hook, HOOKTorchOP)
-        wrap_api_func_and_bind(torch_wrap_api_name.tensor_api_names,
-                               {f: getattr(torch.Tensor, f) for f in dir(torch.Tensor)},
-                               MsConst.TENSOR_DATA_PREFIX, hook, HOOKTorchTensor)
-        wrap_api_func_and_bind(torch_wrap_api_name.functional_api_names,
-                               {f: getattr(torch.nn.functional, f) for f in dir(torch.nn.functional)},
-                               MsConst.OPS_DATA_PREFIX, hook, HOOKTorchFunctionalOP)
-        wrap_api_func_and_bind(torch_wrap_api_name.distributed_api_names,
-                               {f: getattr(torch.distributed, f) for f in dir(torch.distributed)},
-                               MsConst.DISTRIBUTED_DATA_PREFIX, hook, HOOKTorchDistributedOP)
-        wrap_api_func_and_bind(torch_wrap_api_name.npu_api_names, {f: getattr(torch_npu, f) for f in dir(torch_npu)},
-                               MsConst.TORCH_NPU_DATA_PREFIX, hook, HOOKTorchNpuOP)
-        return
-
-    wrap_api_name = get_wrap_api_list()
-    wrap_api_func_and_bind(wrap_api_name.tensor_api_names, {f: getattr(Tensor, f) for f in dir(Tensor)},
-                           MsConst.TENSOR_DATA_PREFIX, hook, HOOKTensor)
-    wrap_api_func_and_bind(wrap_api_name.stub_tensor_api_names, {f: getattr(StubTensor, f) for f in dir(StubTensor)},
-                           MsConst.STUB_TENSOR_DATA_PREFIX, hook, HOOKStubTensor)
-    wrap_api_func_and_bind(wrap_api_name.ops_api_names, {f: getattr(ops, f) for f in dir(ops)},
-                           MsConst.OPS_DATA_PREFIX, hook, HOOKFunctionalOP)
-    wrap_api_func_and_bind(wrap_api_name.mint_api_names, {f: getattr(mint, f) for f in dir(mint)},
-                           MsConst.MINT_DATA_PREFIX, hook, HOOKMintOP)
-    wrap_api_func_and_bind(wrap_api_name.mint_nn_func_api_names, {f: getattr(functional, f) for f in dir(functional)},
-                           MsConst.MINT_NN_FUNC_DATA_PREFIX, hook, HOOKMintNNFunctionalOP)
-    wrap_api_func_and_bind(wrap_api_name.distributed_api_names, {f: getattr(comm_func, f) for f in dir(comm_func)},
-                           MsConst.DISTRIBUTED_DATA_PREFIX, hook, HOOKDistributedOP)