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

msprobe/mindspore/api_accuracy_checker/type_mapping.py

@@ -1,114 +1,114 @@
-from mindspore.common import dtype as mstype
-import numpy as np
-import mindspore
-import torch
-
-INT8 = "Int8"
-UINT8 = "UInt8"
-INT16 = "Int16"
-UINT16 = "UInt16"
-INT32 = "Int32"
-UINT32 = "UInt32"
-INT64 = "Int64"
-UINT64 = "UInt64"
-FLOAT16 = "Float16"
-FLOAT32 = "Float32"
-FLOAT64 = "Float64"
-BOOL = "Bool"
-BFLOAT16 = "BFloat16"
-INT4 = "Int4"
-
-
-dtype_str_to_ms_dtype = {
-    INT8: mstype.int8,
-    UINT8: mstype.uint8,
-    INT16: mstype.int16,
-    UINT16: mstype.uint16,
-    INT32: mstype.int32,
-    UINT32: mstype.uint32,
-    INT64: mstype.int64,
-    UINT64: mstype.uint64,
-    FLOAT16: mstype.float16,
-    FLOAT32: mstype.float32,
-    FLOAT64: mstype.float64,
-    BOOL: mstype.bool_,
-    BFLOAT16: mstype.bfloat16,
-    INT4: mstype.qint4x2
-}
-ms_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_ms_dtype.items()}
-
-
-dtype_str_to_np_dtype = {
-    INT8: np.int8,
-    UINT8: np.uint8,
-    INT16: np.int16,
-    UINT16: np.uint16,
-    INT32: np.int32,
-    UINT32: np.uint32,
-    INT64: np.int64,
-    UINT64: np.uint64,
-    FLOAT16: np.float16,
-    FLOAT32: np.float32,
-    FLOAT64: np.float64,
-    BOOL: np.bool_
-}
-np_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_np_dtype.items()}
-
-dtype_str_to_torch_dtype = {
-    INT8: torch.int8,
-    UINT8: torch.uint8,
-    INT16: torch.int16,
-    INT32: torch.int32,
-    INT64: torch.int64,
-    FLOAT16: torch.float16,
-    FLOAT32: torch.float32,
-    FLOAT64: torch.float64,
-    BOOL: torch.bool,
-    BFLOAT16: torch.bfloat16,
-}
-torch_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_torch_dtype.items()}
-
-MINDSPORE_TENSOR_TYPE_STR = "mindspore.Tensor"
-BOOL_TYPE_STR = "bool"
-INT_TYPE_STR = "int"
-FLOAT_TYPE_STR = "float"
-SLICE_TYPE_STR = "slice"
-TUPLE_TYPE_STR = "tuple"
-STR_TYPE_STR = "str"
-
-api_info_type_str_to_type = {
-    MINDSPORE_TENSOR_TYPE_STR: mindspore.Tensor,
-    BOOL_TYPE_STR: bool,
-    INT_TYPE_STR: int,
-    FLOAT_TYPE_STR: float,
-    SLICE_TYPE_STR: slice,
-    STR_TYPE_STR: str,
-}
-type_to_api_info_type_str = {value: key for key, value in api_info_type_str_to_type.items()}
-
-DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE = np.float64
-DEFAULT_CONSTRUCT_NP_INT_DTYPE = np.float64
-DEFAULT_CONSTRUCT_NP_UINT_DTYPE = np.float64
-
-float_dtype_str_list = [
-    FLOAT16,
-    FLOAT32,
-    FLOAT64,
-    BFLOAT16,
-]
-
-int_dtype_str_list = [
-    INT8,
-    INT16,
-    INT32,
-    INT64,
-    BOOL,
-    INT4,
-]
-
-uint_dtype_str_list = [
-    UINT8,
-    UINT16,
-    UINT32,
-    UINT64,
+from mindspore.common import dtype as mstype
+import numpy as np
+import mindspore
+import torch
+
+INT8 = "Int8"
+UINT8 = "UInt8"
+INT16 = "Int16"
+UINT16 = "UInt16"
+INT32 = "Int32"
+UINT32 = "UInt32"
+INT64 = "Int64"
+UINT64 = "UInt64"
+FLOAT16 = "Float16"
+FLOAT32 = "Float32"
+FLOAT64 = "Float64"
+BOOL = "Bool"
+BFLOAT16 = "BFloat16"
+INT4 = "Int4"
+
+
+dtype_str_to_ms_dtype = {
+    INT8: mstype.int8,
+    UINT8: mstype.uint8,
+    INT16: mstype.int16,
+    UINT16: mstype.uint16,
+    INT32: mstype.int32,
+    UINT32: mstype.uint32,
+    INT64: mstype.int64,
+    UINT64: mstype.uint64,
+    FLOAT16: mstype.float16,
+    FLOAT32: mstype.float32,
+    FLOAT64: mstype.float64,
+    BOOL: mstype.bool_,
+    BFLOAT16: mstype.bfloat16,
+    INT4: mstype.qint4x2
+}
+ms_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_ms_dtype.items()}
+
+
+dtype_str_to_np_dtype = {
+    INT8: np.int8,
+    UINT8: np.uint8,
+    INT16: np.int16,
+    UINT16: np.uint16,
+    INT32: np.int32,
+    UINT32: np.uint32,
+    INT64: np.int64,
+    UINT64: np.uint64,
+    FLOAT16: np.float16,
+    FLOAT32: np.float32,
+    FLOAT64: np.float64,
+    BOOL: np.bool_
+}
+np_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_np_dtype.items()}
+
+dtype_str_to_torch_dtype = {
+    INT8: torch.int8,
+    UINT8: torch.uint8,
+    INT16: torch.int16,
+    INT32: torch.int32,
+    INT64: torch.int64,
+    FLOAT16: torch.float16,
+    FLOAT32: torch.float32,
+    FLOAT64: torch.float64,
+    BOOL: torch.bool,
+    BFLOAT16: torch.bfloat16,
+}
+torch_dtype_to_dtype_str = {value: key for key, value in dtype_str_to_torch_dtype.items()}
+
+MINDSPORE_TENSOR_TYPE_STR = "mindspore.Tensor"
+BOOL_TYPE_STR = "bool"
+INT_TYPE_STR = "int"
+FLOAT_TYPE_STR = "float"
+SLICE_TYPE_STR = "slice"
+TUPLE_TYPE_STR = "tuple"
+STR_TYPE_STR = "str"
+
+api_info_type_str_to_type = {
+    MINDSPORE_TENSOR_TYPE_STR: mindspore.Tensor,
+    BOOL_TYPE_STR: bool,
+    INT_TYPE_STR: int,
+    FLOAT_TYPE_STR: float,
+    SLICE_TYPE_STR: slice,
+    STR_TYPE_STR: str,
+}
+type_to_api_info_type_str = {value: key for key, value in api_info_type_str_to_type.items()}
+
+DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE = np.float64
+DEFAULT_CONSTRUCT_NP_INT_DTYPE = np.float64
+DEFAULT_CONSTRUCT_NP_UINT_DTYPE = np.float64
+
+float_dtype_str_list = [
+    FLOAT16,
+    FLOAT32,
+    FLOAT64,
+    BFLOAT16,
+]
+
+int_dtype_str_list = [
+    INT8,
+    INT16,
+    INT32,
+    INT64,
+    BOOL,
+    INT4,
+]
+
+uint_dtype_str_list = [
+    UINT8,
+    UINT16,
+    UINT32,
+    UINT64,
 ]

msprobe/mindspore/api_accuracy_checker/utils.py

@@ -1,63 +1,80 @@
-from msprobe.core.common.exceptions import ApiAccuracyCheckerException
-from msprobe.core.common.log import logger
-
-def check_and_get_from_json_dict(dict_instance, key, key_description, accepted_type=None, accepted_value=None):
-    '''
-    Args:
-        dict_instance: dict, dict parsed from input json
-        key: str
-        key_description: str
-        accepted_type: tuple
-        accepted_value: Union[tuple, list]
-
-    Return:
-        value, the corresponding value of "key" in "dict_instance"
-
-    Exception:
-        raise ApiAccuracyCheckerException.ParseJsonFailed error when
-        1. dict_instance is not a dict
-        2. value is None
-        3. value is not accepted type
-        4. value is not accepted value
-    '''
-    parse_failed_exception = ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed)
-    if not isinstance(dict_instance, dict):
-        logger.error_log_with_exp("check_and_get_from_json_dict failed: input is not a dict", parse_failed_exception)
-    value = dict_instance.get(key)
-    if value is None:
-        logger.error_log_with_exp(f"check_and_get_from_json_dict failed: {key_description} is missing",
-                                  parse_failed_exception)
-    elif accepted_type is not None and not isinstance(value, accepted_type):
-        logger.error_log_with_exp(
-            f"check_and_get_from_json_dict failed: {key_description} is not accepted type: {accepted_type}",
-            parse_failed_exception)
-    elif accepted_value is not None and value not in accepted_value:
-        logger.error_log_with_exp(
-            f"check_and_get_from_json_dict failed: {key_description} is not accepted value: {accepted_value}",
-            parse_failed_exception)
-    return value
-
-def convert_to_tuple(input):
-    if isinstance(input, (tuple, list)):
-        return tuple(input)
-    else:
-        input_list = [input]
-        return tuple(input_list)
-
-class GlobalContext:
-    def __init__(self):
-        self.is_constructed = True
-        self.dump_data_dir = ""
-
-    def init(self, is_constructed, dump_data_dir):
-        self.is_constructed = is_constructed
-        self.dump_data_dir = dump_data_dir
-
-    def get_dump_data_dir(self):
-        return self.dump_data_dir
-
-    def get_is_constructed(self):
-        return self.is_constructed
-
-
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.core.common.const import Const
+from msprobe.mindspore.api_accuracy_checker.type_mapping import float_dtype_str_list
+from msprobe.mindspore.common.log import logger
+
+def check_and_get_from_json_dict(dict_instance, key, key_description, accepted_type=None, accepted_value=None):
+    '''
+    Args:
+        dict_instance: dict, dict parsed from input json
+        key: str
+        key_description: str
+        accepted_type: tuple
+        accepted_value: Union[tuple, list]
+
+    Return:
+        value, the corresponding value of "key" in "dict_instance"
+
+    Exception:
+        raise ApiAccuracyCheckerException.ParseJsonFailed error when
+        1. dict_instance is not a dict
+        2. value is None
+        3. value is not accepted type
+        4. value is not accepted value
+    '''
+    parse_failed_exception = ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed)
+    if not isinstance(dict_instance, dict):
+        logger.error_log_with_exp("check_and_get_from_json_dict failed: input is not a dict", parse_failed_exception)
+    value = dict_instance.get(key)
+    if value is None:
+        logger.error_log_with_exp(f"check_and_get_from_json_dict failed: {key_description} is missing",
+                                  parse_failed_exception)
+    elif accepted_type is not None and not isinstance(value, accepted_type):
+        logger.error_log_with_exp(
+            f"check_and_get_from_json_dict failed: {key_description} is not accepted type: {accepted_type}",
+            parse_failed_exception)
+    elif accepted_value is not None and value not in accepted_value:
+        logger.error_log_with_exp(
+            f"check_and_get_from_json_dict failed: {key_description} is not accepted value: {accepted_value}",
+            parse_failed_exception)
+    return value
+
+def convert_to_tuple(input):
+    if isinstance(input, (tuple, list)):
+        return tuple(input)
+    else:
+        input_list = [input]
+        return tuple(input_list)
+
+def trim_output_compute_element_list(compute_element_list, forward_or_backward):
+    '''
+    Args:
+        compute_element_list: List[ComputeElement]
+        forward_or_backward: str, Union["forward", "backward"]
+    '''
+    trimmed_list = []
+    for compute_element in compute_element_list:
+        if compute_element.get_parameter() is None or \
+            (forward_or_backward == Const.BACKWARD and compute_element.get_dtype() not in float_dtype_str_list):
+            # trim case: 1. parameter is None. 2. backward output has non float parameter
+            continue
+        trimmed_list.append(compute_element)
+    return trimmed_list
+
+class GlobalContext:
+    def __init__(self):
+        self.is_constructed = True
+        self.dump_data_dir = ""
+
+    def init(self, is_constructed, dump_data_dir):
+        self.is_constructed = is_constructed
+        self.dump_data_dir = dump_data_dir
+
+    def get_dump_data_dir(self):
+        return self.dump_data_dir
+
+    def get_is_constructed(self):
+        return self.is_constructed
+
+
 global_context = GlobalContext()

msprobe/mindspore/cell_processor.py

@@ -1,34 +1,58 @@
-from msprobe.core.data_dump.scope import ModuleRangeScope
-from msprobe.core.common.const import Const
-from msprobe.mindspore.common.log import logger
-
-
-class CellProcessor:
-    cell_count = {}
-
-    def __init__(self, scope):
-        if isinstance(scope, ModuleRangeScope):
-            self.scope = scope
-        else:
-            self.scope = None
-        
-    @staticmethod
-    def set_cell_count(cell_name):
-        if cell_name not in CellProcessor.cell_count:
-            CellProcessor.cell_count[cell_name] = 0
-        else:
-            CellProcessor.cell_count[cell_name] += 1
-        return CellProcessor.cell_count[cell_name]
-    
-    def node_hook(self, name_prefix, start_or_stop, **kwargs):
-        def begin_hook(cell, input):
-            index = self.set_cell_count(name_prefix)
-            cell.mindstudio_reserved_name = full_name = name_prefix + Const.SEP + str(index)
-            if self.scope:
-                self.scope.begin_module(full_name)
-    
-        def end_hook(cell, input, output):
-            if self.scope:
-                self.scope.end_module(cell.mindstudio_reserved_name)
-
-        return begin_hook if Const.START == start_or_stop else end_hook
+from msprobe.core.data_dump.scope import ModuleRangeScope
+from msprobe.core.common.const import Const
+
+
+class CellProcessor:
+    cell_count = {}
+    cell_stack = []
+    api_parent_node = ""
+    module_node = {}
+
+    def __init__(self, scope):
+        if isinstance(scope, ModuleRangeScope):
+            self.scope = scope
+        else:
+            self.scope = None
+
+    @staticmethod
+    def set_cell_count(cell_name):
+        if cell_name not in CellProcessor.cell_count:
+            CellProcessor.cell_count[cell_name] = 0
+        else:
+            CellProcessor.cell_count[cell_name] += 1
+        return CellProcessor.cell_count[cell_name]
+    
+    @classmethod
+    def reset_cell_stats(cls):
+        cls.cell_count = {}
+        cls.cell_stack = []
+        cls.api_parent_node = ""
+        cls.module_node = {}
+    
+    def node_hook(self, name_prefix, start_or_stop, **kwargs):
+        def begin_hook(cell, input):
+            index = self.set_cell_count(name_prefix)
+            cell.mindstudio_reserved_name = full_name = name_prefix + Const.SEP + str(index)
+            if CellProcessor.cell_stack:
+                CellProcessor.module_node[full_name] = CellProcessor.cell_stack[-1]
+            else:
+                CellProcessor.module_node[full_name] = None
+            
+            CellProcessor.cell_stack.append(full_name)
+            CellProcessor.api_parent_node = full_name
+
+            if self.scope:
+                self.scope.begin_module(full_name)
+
+        def end_hook(cell, input, output):
+            if CellProcessor.cell_stack:
+                CellProcessor.cell_stack.pop()
+            if CellProcessor.cell_stack:
+                CellProcessor.api_parent_node = CellProcessor.cell_stack[-1]
+            else:
+                CellProcessor.api_parent_node = None
+
+            if self.scope:
+                self.scope.end_module(cell.mindstudio_reserved_name)
+
+        return begin_hook if Const.START == start_or_stop else end_hook

msprobe/mindspore/common/const.py

@@ -1,87 +1,108 @@
-import numpy as np
-import mindspore as ms
-
-from msprobe.core.common.const import Const as CoreCost
-
-
-class Const:
-    CELL = "cell"
-    API = "api"
-    KERNEL = "kernel"
-    TOOL_LEVEL_DICT = {
-        CoreCost.LEVEL_L0: CELL,
-        CoreCost.LEVEL_L1: API,
-        CoreCost.LEVEL_L2: KERNEL
-    }
-    PYNATIVE_MODE = "pynative"
-    GRAPH_GE_MODE = "graph_ge"
-    GRAPH_KBYK_MODE = "graph_kbyk"
-
-
-class FreeBenchmarkConst:
-    DEFAULT_DEVICE = "npu"
-    DEFAULT_STAGE = "forward"
-    DEFAULT_DUMP_LEVEL = CoreCost.LEVEL_L1
-    DEFAULT_PERT_TYPE = "improve_precision"
-    DEFAULT_HANDLER_TYPE = "check"
-    FIX_HANDLER_MODE = "fix"
-    ADD_NOISE = "add_noise"
-    BIT_NOISE = "bit_noise"
-    NO_CHANGE = "no_change"
-    IMPROVE_PRECISION = "improve_precision"
-    CHECK = "check"
-    FIX = "fix"
-    DEVICE_LIST = ["npu"]
-    STAGE_LIST = ["forward"]
-    DUMP_LEVEL_LIST = [CoreCost.LEVEL_L1]
-    PERT_TYPE_LIST = [IMPROVE_PRECISION, ADD_NOISE, BIT_NOISE, NO_CHANGE]
-    HANDLER_TYPE_LIST = [CHECK, FIX]
-    COMMUNICATION_API_LIST = [
-        "mindspore.communication.comm_func.all_gather_into_tensor",
-        "mindspore.communication.comm_func.gather_into_tensor",
-        "mindspore.communication.comm_func.all_reduce",
-        "mindspore.communication.comm_func.reduce",
-        "mindspore.communication.comm_func.reduce_scatter_tensor"
-        ]
-    NO_CHANGE_ERROR_THRESHOLD = 1.0
-    SYMBOL_FLIPPING_RATIO = 8.0
-    OPS_PREFIX = "mindspore.ops."
-    Tensor_PREFIX = "mindspore.Tensor."
-    MINT_PREFIX = "mindspore.mint."
-    MINT_NN_FUNC_PREFIX = "mindspore.mint.nn.functional."
-    COMM_PREFIX = "mindspore.communication.comm_func."
-
-    API_PREFIX_DICT = {
-        "ops": OPS_PREFIX,
-        "Tensor": Tensor_PREFIX,
-        "mint": MINT_PREFIX,
-        "mint.nn.functional": MINT_NN_FUNC_PREFIX,
-        "communication": COMM_PREFIX
-    }
-
-    PERT_VALUE_DICT = {
-        ms.bfloat16: 1e-4,
-        ms.float16: 1e-6,
-        ms.float32: 1e-8,
-        ms.float64: 1e-16
-    }
-
-    ERROR_THRESHOLD = {
-        ms.float16: 1.002,
-        ms.float32: 1.0002
-    }
-
-    PERT_BIT_DICT = {
-        ms.float16: np.int16,
-        ms.float32: np.int32,
-        ms.float64: np.int64
-    }
-
-    MS_NUMPY_DTYPE_DICT = {
-        ms.int16: np.int16,
-        ms.int32: np.int32,
-        ms.int64: np.int64,
-        ms.float16: np.float16,
-        ms.float32: np.float32,
-        ms.float64: np.float64
-    }
+import numpy as np
+import mindspore as ms
+
+from msprobe.core.common.const import Const as CoreConst
+
+
+class Const:
+    CELL = "cell"
+    API = "api"
+    KERNEL = "kernel"
+    TOOL_LEVEL_DICT = {
+        CoreConst.LEVEL_L0: CELL,
+        CoreConst.LEVEL_L1: API,
+        CoreConst.LEVEL_L2: KERNEL
+    }
+    PYNATIVE_MODE = "pynative"
+    GRAPH_GE_MODE = "graph_ge"
+    GRAPH_KBYK_MODE = "graph_kbyk"
+    JIT_LEVEL = "jit_level"
+    JIT_LEVEL_O0 = "O0"
+    JIT_LEVEL_O1 = "O1"
+    JIT_LEVEL_O2 = "O2"
+    ASCEND_910A = "ascend910"
+
+    OPS_PREFIX = "mindspore.ops."
+    Tensor_PREFIX = "mindspore.Tensor."
+    MINT_PREFIX = "mindspore.mint."
+    MINT_NN_FUNC_PREFIX = "mindspore.mint.nn.functional."
+    COMM_PREFIX = "mindspore.communication.comm_func."
+    COMMUNICATION_API_LIST = [
+        "mindspore.communication.comm_func.all_gather_into_tensor",
+        "mindspore.communication.comm_func.gather_into_tensor",
+        "mindspore.communication.comm_func.all_reduce",
+        "mindspore.communication.comm_func.reduce",
+        "mindspore.communication.comm_func.reduce_scatter_tensor"
+        ]
+    TENSOR_DATA_PREFIX = "Tensor."
+    STUB_TENSOR_DATA_PREFIX = "Tensor."
+    OPS_DATA_PREFIX = "Functional."
+    MINT_DATA_PREFIX = "Mint."
+    MINT_NN_FUNC_DATA_PREFIX = "MintFunctional."
+    DISTRIBUTED_DATA_PREFIX = "Distributed."
+
+    SUPPORTED_API_LIST_FILE = "support_wrap_ops.yaml"
+    SUPPORTED_TENSOR_LIST_KEY = "tensor"
+    SUPPORTED_OPS_LIST_KEY = "ops"
+    SUPPORTED_MINT_LIST_KEY = "mint.ops"
+    SUPPORTED__MINT_NN_FUNC_LIST_KEY = "mint.nn.functional"
+    SUPPORTED_COMM_LIST_KEY = "communication.comm_func"
+
+    DROPOUT_API_NAME_PREFIX = "dropout"
+
+
+class FreeBenchmarkConst:
+    ADD_NOISE = "add_noise"
+    BIT_NOISE = "bit_noise"
+    NO_CHANGE = "no_change"
+    EXCHANGE_VALUE = "change_value"
+    IMPROVE_PRECISION = "improve_precision"
+    CHECK = "check"
+    FIX = "fix"
+    DEFAULT_DEVICE = "npu"
+    DEFAULT_STAGE = CoreConst.FORWARD
+    DEFAULT_DUMP_LEVEL = "L1"
+    DEFAULT_PERT_TYPE = IMPROVE_PRECISION
+    DEFAULT_HANDLER_TYPE = CHECK
+    DEVICE_LIST = [DEFAULT_DEVICE]
+    STAGE_LIST = [CoreConst.FORWARD]
+    DUMP_LEVEL_LIST = [DEFAULT_DUMP_LEVEL]
+    PERT_TYPE_LIST = [IMPROVE_PRECISION, ADD_NOISE, BIT_NOISE, NO_CHANGE, EXCHANGE_VALUE]
+    HANDLER_TYPE_LIST = [CHECK, FIX]
+    NO_CHANGE_ERROR_THRESHOLD = 1.0
+    SYMBOL_FLIPPING_RATIO = 8.0
+
+    API_PREFIX_DICT = {
+        "ops": Const.OPS_PREFIX,
+        "Tensor": Const.Tensor_PREFIX,
+        "mint": Const.MINT_PREFIX,
+        "mint.nn.functional": Const.MINT_NN_FUNC_PREFIX,
+        "communication": Const.COMM_PREFIX
+    }
+
+    PERT_VALUE_DICT = {
+        ms.bfloat16: 1e-4,
+        ms.float16: 1e-6,
+        ms.float32: 1e-8,
+        ms.float64: 1e-16
+    }
+
+    ERROR_THRESHOLD = {
+        ms.float16: 1.002,
+        ms.float32: 1.0002
+    }
+
+    PERT_BIT_DICT = {
+        ms.float16: np.int16,
+        ms.float32: np.int32,
+        ms.float64: np.int64
+    }
+
+    MS_NUMPY_DTYPE_DICT = {
+        ms.int16: np.int16,
+        ms.int32: np.int32,
+        ms.int64: np.int64,
+        ms.float16: np.float16,
+        ms.float32: np.float32,
+        ms.float64: np.float64
+    }