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

msprobe/mindspore/compare/layer_mapping.py

@@ -1,146 +0,0 @@
-import re
-
-from msprobe.core.common.const import Const
-from msprobe.core.common.log import logger
-from msprobe.core.common.utils import CompareException
-
-
-class Trie:
-    def __init__(self, type_name=None, has_data=False):
-        self.type_name = type_name
-        self.call_count_list = []
-        self.children = {}
-        self.has_data = has_data
-        self.node_type = None
-
-    def __repr__(self):
-        return (f"Node(type_name={self.type_name}, "
-                f"has_data={self.has_data}, call number={len(self.call_count_list)})")
-
-    def insert(self, word, word_type="func"):
-        parts = word.split(Const.SEP)
-        if len(parts) < 2:
-            logger.error('result dataframe elements can not be access.')
-            raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR)
-        """
-        xxx, node_name, type_name, execute_num
-        etc: Cell.network_with_loss.language_model.encoder.layers.1.attention.out_proj.RowParallelLinear.1
-        prefix_name_list: Cell.network_with_loss.language_model.encoder.layers.1.attention
-        node_name: out_proj
-        type_name: RowParallelLinear
-        call_count: 1
-        """
-        type_name = parts[-2]
-        call_count = parts[-1]
-        node = self
-        prefix_name_list = parts[:-2]
-
-        for name in prefix_name_list:
-            if name not in node.children:
-                node.children[name] = Trie()
-            node = node.children[name]
-            if node.type_name is None:
-                node.type_name = name
-
-        node.type_name = type_name
-        node.has_data = True
-        node.call_count_list.append(call_count)
-        node.node_type = word_type
-
-
-class DFSConverter:
-    def __init__(self, mapping, max_depth=100):
-        self.mapping = mapping
-        self.max_depth = max_depth
-        self.result = {}
-
-    def traverse_and_collect(self, node, path="", mapping_path="", depth=0):
-        if depth > self.max_depth:
-            logger.error("The converted data depth is too large, please check the data")
-            raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
-
-        if node is None:
-            return self.result
-
-        type_name = node.type_name
-        if node.has_data:
-            for count in node.call_count_list:
-                origin_name = f"{path}.{count}" if node.node_type == "Cell" else f"{path}.{type_name}.{count}"
-                mapping_name = f"{mapping_path}.{count}" if node.node_type == "Cell" else f"{mapping_path}.{type_name}.{count}"
-                self.result[origin_name] = mapping_name
-
-        name_mapping = self.mapping.get(type_name, {})
-
-        for child_name, child_node in node.children.items():
-            new_path = f"{path}.{child_name}" if path else child_name
-            converted_name = name_mapping.get(child_name, child_name)
-            new_mapping_path = f"{mapping_path}.{converted_name}" if mapping_path else converted_name
-            self.traverse_and_collect(child_node, new_path, new_mapping_path, depth+1)
-
-        return self.result
-
-
-def get_mapping_list(ms_tree, mapping):
-    dfs_converter = DFSConverter(mapping)
-    ms_pt_mapping = dfs_converter.traverse_and_collect(ms_tree)
-    mapping_list = []
-    for ms_name, pt_name in ms_pt_mapping.items():
-        pt_name = re.sub(r"^Cell", "Module", pt_name)
-        mapping_list.append((ms_name, pt_name))
-    return mapping_list
-
-
-def get_prefix_mapping(scope_list):
-    """layer name to layer name.class_name"""
-    layer_mapping = {}
-    for name, v in scope_list.items():
-        origin_data = v.get("origin_data")
-        if not origin_data.startswith(("Cell", "Module")):
-            continue
-        name_list = name.split(Const.SEP)
-        if len(name_list) < 2:
-            logger.error('result dataframe elements can not be access.')
-            raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR)
-        prefix_name_list = name_list[:-2] + [name_list[-1]]
-        prefix_name = Const.SEP.join(prefix_name_list)
-        layer_mapping[prefix_name] = name
-    return layer_mapping
-
-
-def get_layer_mapping(ms_scope_list, pt_scope_list, mapping):
-    # 1. get layer prefix to full name mapping
-    # ect: Cell.network_with_loss.language_model.embedding.3 : Cell.network_with_loss.language_model.embedding.Embedding.3
-    ms_prefix2fullname = get_prefix_mapping(ms_scope_list)
-    # 2. build trie tree
-    ms_tree = Trie(type_name="Cell")
-    for k, r in ms_scope_list.items():
-        origin_data_name = r.get('origin_data')
-        data_type = origin_data_name.split(Const.SEP)[0]
-        ms_tree.insert(k, data_type)
-    msname2ptname = get_mapping_list(ms_tree, mapping)
-    # 3. get pt layer prefix to full name mapping
-    # ect: Module.network_with_loss.language_model.embedding.3 : Module.network_with_loss.language_model.embedding.Embedding.3
-    pt_prefix2fullname = get_prefix_mapping(pt_scope_list)
-
-    final_mapping = []
-    for ms_name, pt_name in msname2ptname:
-        final_ms_name = ms_name
-        final_pt_name = pt_name
-        # cell
-        if ms_name in ms_prefix2fullname:
-            final_ms_name = ms_prefix2fullname.get(ms_name)
-            final_pt_name = pt_prefix2fullname.get(pt_name, None)
-        # func
-        elif final_ms_name in ms_scope_list:
-            final_ms_name = ms_scope_list.get(ms_name)['origin_data']
-            # remove forward/backward
-            final_ms_name = Const.SEP.join(final_ms_name.split(Const.SEP)[:-1])
-            final_pt_name = pt_scope_list.get(pt_name, None)
-            if final_pt_name:
-                final_pt_name = final_pt_name['origin_data']
-                final_pt_name = Const.SEP.join(final_pt_name.split(Const.SEP)[:-1])
-        else:
-            continue
-        final_mapping.append((final_ms_name, final_pt_name))
-
-    return final_mapping

msprobe/mindspore/compare/modify_mapping.py

@@ -1,107 +0,0 @@
-from msprobe.core.common.const import Const
-from msprobe.core.common.log import logger
-
-def find_regard_scope(lines, start_sign, end_sign):
-    # 找出 start_pos 和 end_pos
-    start_pos = end_pos = -1
-    for idx, ii in enumerate(lines):
-        if start_sign in ii:
-            start_pos = idx
-        elif end_sign in ii:
-            end_pos = idx
-            break
-    return start_pos, end_pos
-
-
-def find_stack_func_list(lines):
-    res_list = []
-    # 过滤和处理 regard_scope
-    for line in lines:
-        ele_list = line.split(',')
-        file_ele = ele_list[Const.STACK_FILE_INDEX]
-        if any(ii in file_ele for ii in Const.FILE_SKIP_LIST):
-            continue
-
-        func_ele = ele_list[Const.STACK_FUNC_INDEX]
-        if any(ii in func_ele for ii in Const.FUNC_SKIP_LIST):
-            continue
-
-        in_func_name = func_ele.split()[Const.STACK_FUNC_ELE_INDEX]
-
-        res_list.append(in_func_name)
-    # 反转res_list并生成final_res
-    reversed_list = res_list[::-1]
-    return reversed_list
-
-
-def get_duplicated_name(components):
-    duplicated_components = components
-    if len(components) < 3 or components[Const.CONSTRUCT_NAME_INDEX].isdigit():
-        logger.warning("key in construct.json is shorter than 3 parts or not name valid.")
-    else:
-        # 重复name，如Functional.add.add.X ward
-        duplicated_components = components[:Const.CONSTRUCT_NAME_INDEX + 1] + components[Const.CONSTRUCT_NAME_INDEX:]
-    return duplicated_components
-
-
-def modify_mapping_with_stack(stack, construct):
-    if not stack or not construct:
-        return {}
-
-    # 是否是mindspore的数据结构
-    is_ms = any("Cell" in ii for ii in construct)
-    # 调整后的mapping结构
-    final_pres = {}
-    # 查看归属关系
-    for key in construct:
-        key_components = key.split(Const.SEP)
-        code_list = stack.get(key, None)
-        parent_node = construct.get(key, None)
-        # 名称如果非标准开头，转为标准开头
-        if not key.startswith(("Module", "Cell")):
-            # 如果没有拿到父属scope name，默认顶级域名为Module或Cell
-            if not parent_node:
-                # 将节点名字转为标准的Module或Cell
-                key_components[0] = "Cell" if is_ms else "Module"
-                # 重复该节点的名字作为类型 如add.add add在-3位置
-                duplicated_components = get_duplicated_name(key_components)
-                modified_key = Const.SEP.join(duplicated_components)
-
-                modified_key = modified_key.replace(".forward", "").replace(".backward", "")
-                final_pres[modified_key] = {Const.ORIGIN_DATA: key, Const.SCOPE: None, Const.STACK: None}
-                continue
-            parent = parent_node.split(Const.SEP)
-            if len(parent) < 4:
-                logger.info(f"Parent name in construct.json is not valid")
-                continue
-            parent_idx = Const.NAME_FIRST_POSSIBLE_INDEX if not \
-            parent[Const.NAME_FIRST_POSSIBLE_INDEX].isdigit() else Const.NAME_SECOND_POSSIBLE_INDEX
-            parent_name = parent[parent_idx]
-
-            if code_list:
-                # {name}.Class.count_number.X ward Or {name}.Class.count_number.X ward.ele_number
-                if parent_name.endswith('s'):
-                    parent_name = parent_name[:-1]
-                if len(key_components) < 3:
-                    logger.info("The length of key in construct is less than 3, please check")
-                    continue
-                # {name}.count_number.X ward
-                func_name = key_components[-3]
-                start_pos, end_pos = find_regard_scope(code_list, func_name, parent_name)
-
-                # 获取指定范围的代码
-                regard_scope = code_list[start_pos:end_pos]
-
-                func_stack_list = find_stack_func_list(regard_scope)
-            else:
-                func_stack_list = []
-            # 组合逻辑：parent的节点名（到节点名字为止）加上调用栈名[reversed_list]加上原来key重复key的节点名[key_components[1:-2] + key_components[-3:]]
-            final_res_key = Const.SEP.join(parent[:parent_idx + 1] + func_stack_list +
-                                     key_components[1:Const.CONSTRUCT_NAME_INDEX + 1] + key_components[Const.CONSTRUCT_NAME_INDEX:])
-            final_res_key = final_res_key.strip(".forward").strip(".backward")
-        else:
-            final_res_key = Const.SEP.join(key_components[:-2] + [key_components[-1]])
-            func_stack_list = []
-        final_pres[final_res_key] = {Const.ORIGIN_DATA: key, Const.SCOPE: parent_node,
-                                     Const.STACK: Const.SEP.join(func_stack_list) if func_stack_list else None}
-    return final_pres

msprobe/mindspore/free_benchmark/decorator/dec_forward.py

@@ -1,57 +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.mindspore.common.const import Const, FreeBenchmarkConst
-from msprobe.mindspore.free_benchmark.common.config import Config
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-from msprobe.mindspore.free_benchmark.handler.handler_factory import HandlerFactory
-from msprobe.mindspore.free_benchmark.perturbation.perturbation_factory import PerturbationFactory
-
-
-class ForwardSelfChecker:
-
-    def __init__(self, api_name: str):
-        self.api_name = api_name
-
-    def handle(self, params: HandlerParams):
-        """
-        装饰器实际执行逻辑
-
-        """
-        perturbation = PerturbationFactory.create(self.api_name)
-        params.fuzzed_result = perturbation.handle(params)
-        params.original_result = params.original_func(*params.args, **params.kwargs)
-        if params.fuzzed_result is not False:
-            return self.deal_fuzzed_and_original_result(params)
-        return params.original_result
-
-    def get_compare_data(self, params: HandlerParams):
-        if self.api_name not in Const.COMMUNICATION_API_LIST:
-            return
-        # 以下为通讯类api处理逻辑
-        params.fuzzed_result = params.fuzzed_value
-        if Config.pert_type == FreeBenchmarkConst.IMPROVE_PRECISION:
-            params.original_result = params.args
-        else:
-            params.original_result = params.args[params.index]
-
-    def deal_fuzzed_and_original_result(self, params: HandlerParams):
-        original_result = params.original_result
-        self.get_compare_data(params)
-        handler = HandlerFactory.create(self.api_name)
-        result = handler.handle(params)
-        if self.api_name in Const.COMMUNICATION_API_LIST:
-            result = original_result
-        return result

msprobe/mindspore/free_benchmark/decorator/decorator_factory.py

@@ -1,122 +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 sys
-import traceback
-from functools import wraps
-from typing import Dict, List, Tuple
-
-from mindspore import ops
-
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.free_benchmark.common.config import Config
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-from msprobe.mindspore.free_benchmark.decorator.dec_forward import ForwardSelfChecker
-from msprobe.mindspore.runtime import Runtime
-
-
-def decorate(original_func, decorate_func, api_name=None):
-    """
-    总装饰器
-    """
-    @wraps(original_func)
-    def fuzz_wrapper(*args, **kwargs):
-
-        def __exec_decorate_func():
-            params = data_pre_deal(api_name, original_func, *args, **kwargs)
-            result = decorate_func(params)
-            return result
-
-        try:
-            if Runtime.rank_id == -1:
-                Runtime.rank_id = os.environ.get("RANK_ID", -1)
-            if need_wrapper_func():
-                logger.info(f"[{api_name}] is checking.")
-                return __exec_decorate_func()
-        except Exception as e:
-            logger.error(f"[{api_name}] Error: {str(e)}")
-            logger.error(f"[{api_name}] Error detail: {traceback.format_exc()}")
-
-        return original_func(*args, **kwargs)
-
-    return fuzz_wrapper
-
-
-def decorate_forward_function(func, api_name=None):
-    """
-    前向装饰器
-    """
-
-    if not api_name:
-        api_name = func.__name__
-
-    def forward_func(params: HandlerParams):
-        forward = ForwardSelfChecker(api_name)
-        result = forward.handle(params)
-        return result
-
-    return decorate(func, forward_func, api_name)
-
-
-def stack_depth_check() -> bool:
-    nested_depth = 1
-    frame = sys._getframe(1)
-    while frame:
-        if frame.f_code.co_name == "fuzz_wrapper":
-            nested_depth -= 1
-            if nested_depth < 0:
-                return False
-        frame = frame.f_back
-    return True
-
-
-def get_target_arg_index(args: Tuple) -> int:
-    """
-    类型校验
-
-    """
-    for i, arg in enumerate(args):
-        if ops.is_tensor(arg):
-            if not ops.is_floating_point(arg):
-                continue
-            return i
-        if isinstance(arg, (List, Tuple, Dict)):
-            return i
-    return -1
-
-
-def data_pre_deal(api_name, func, *args, **kwargs):
-    params = HandlerParams()
-    params.args = args
-    params.kwargs = kwargs
-    params.original_func = func
-    index = get_target_arg_index(args)
-    if index == -1:
-        raise Exception(f"{api_name} has no supported input type")
-    params.index = index
-    return params
-
-
-def need_wrapper_func():
-    if not (Runtime.is_running and Config.is_enable):
-        return False
-    if not stack_depth_check():
-        return False
-    if Config.steps and Runtime.step_count not in Config.steps:
-        return False
-    if Config.ranks and Runtime.rank_id != -1 and Runtime.rank_id not in Config.ranks:
-        return False
-    return True

msprobe/pytorch/functional/module_dump.py

@@ -1,84 +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 torch
-import torch.nn as nn
-from msprobe.core.common.const import Const
-from msprobe.core.common.exceptions import MsprobeException
-from msprobe.core.data_dump.scope import BaseScope
-from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.debugger.precision_debugger import PrecisionDebugger
-from msprobe.pytorch.hook_module.api_registry import api_register
-from msprobe.pytorch.service import torch_version_above_or_equal_2
-
-hook_handle_list = []
-
-
-def module_dump(module, dump_name):
-    if not isinstance(module, nn.Module):
-        logger.error("The parameter module in module_dump must be a Module subclass.")
-        raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR)
-    if not isinstance(dump_name, str):
-        logger.error("The parameter dump_name in module_dump must be a str type.")
-        raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR)
-
-    api_register.api_originality()
-    register_hook(module, dump_name)
-
-
-def module_dump_end():
-    api_register.api_modularity()
-    remove_hook()
-    hook_handle_list.clear()
-
-
-def register_hook(module, dump_name):
-    prefix = BaseScope.Module_Type_Module + Const.SEP + dump_name + Const.SEP + module.__class__.__name__ + Const.SEP
-
-    pdg = PrecisionDebugger()
-    _, forward_hook, backward_hook, forward_hook_torch_version_below_2 = \
-        pdg.service.build_hook(BaseScope.Module_Type_Module, prefix)
-
-    if torch_version_above_or_equal_2:
-        forward_hook_handle = module.register_forward_hook(forward_hook, with_kwargs=True)
-        hook_handle_list.append(forward_hook_handle)
-    else:
-        pdg.service.check_register_full_backward_hook(module)
-        full_backward_hook_handle = module.register_full_backward_hook(
-            pdg.service.module_processor.node_hook(prefix + Const.BACKWARD, Const.STOP))
-        forward_hook_handle = module.register_forward_hook(forward_hook_torch_version_below_2)
-        hook_handle_list.extend([full_backward_hook_handle, forward_hook_handle])
-    pdg.service.check_register_full_backward_hook(module)
-    full_backward_hook_handle = module.register_full_backward_hook(backward_hook)
-
-    forward_pre_hook_handle = module.register_forward_pre_hook(
-        pdg.service.module_processor.node_hook(prefix + Const.FORWARD, Const.START))
-    forward_hook_handle = module.register_forward_hook(
-        pdg.service.module_processor.node_hook(prefix + Const.FORWARD, Const.STOP))
-    hook_handle_list.extend([full_backward_hook_handle, forward_pre_hook_handle, forward_hook_handle])
-
-    if torch_version_above_or_equal_2:
-        backward_pre_hook_handle = module.register_full_backward_pre_hook(
-            pdg.service.module_processor.node_hook(prefix + Const.BACKWARD, Const.START))
-        pdg.service.check_register_full_backward_hook(module)
-        full_backward_hook_handle = module.register_full_backward_hook(
-            pdg.service.module_processor.node_hook(prefix + Const.BACKWARD, Const.STOP))
-        hook_handle_list.extend([backward_pre_hook_handle, full_backward_hook_handle])
-
-
-def remove_hook():
-    for hook_handle in hook_handle_list:
-        if isinstance(hook_handle, torch.utils.hooks.RemovableHandle):
-            hook_handle.remove()