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

msprobe/mindspore/api_accuracy_checker/base_compare_algorithm.py

@@ -0,0 +1,197 @@
+from abc import ABC, abstractmethod
+
+import mindspore
+import torch
+import numpy as np
+
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.const import CompareConst, MsCompareConst
+
+class CompareResult:
+    def __init__(self, compare_value, pass_status, err_msg):
+        self.compare_value = compare_value
+        self.pass_status = pass_status
+        self.err_msg = err_msg
+
+
+class BaseCompareAlgorithm(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+        self.compare_algorithm_name = None
+        self.err_msg_mapping = {
+            CompareConst.COSINE: {
+                CompareConst.PASS: "",
+                CompareConst.ERROR: f"cosine similarity is less than threshold: {CompareConst.COS_THRESHOLD} ",
+                CompareConst.SKIP: "two inputs are not valid for computing cosine similarity, skip comparing ",
+            },
+            CompareConst.MAX_ABS_ERR: {
+                CompareConst.PASS: "",
+                CompareConst.ERROR: "max absolute difference is greater than " \
+                    f"threshold: {CompareConst.MAX_ABS_ERR_THRESHOLD} ",
+                CompareConst.SKIP: "two inputs are not valid for computing max absolute difference, skip comparing ",
+            },
+            CompareConst.MAX_RELATIVE_ERR: {
+                CompareConst.PASS: "",
+                CompareConst.ERROR: "",
+                CompareConst.SKIP: "",
+            },
+        }
+
+    def __call__(self, bench_compute_element, tested_compute_element):
+        '''
+        Args:
+            bench_compute_element: ComputeElement
+            tested_compute_element: ComputeElement
+
+        Return:
+            compare_result: CompareResult
+        '''
+        if self.check_validity(bench_compute_element, tested_compute_element):
+            compare_value = self.run_compare(bench_compute_element, tested_compute_element)
+            pass_status = self.check_pass(compare_value)
+        else:
+            logger.warning(f"not suitable for computing {self.compare_algorithm_name}, skip this.")
+            compare_value = None
+            pass_status = CompareConst.SKIP
+
+        err_msg = self.err_msg_mapping.get(self.compare_algorithm_name).get(pass_status)
+
+        compare_result = CompareResult(compare_value, pass_status, err_msg)
+        return compare_result
+
+    @staticmethod
+    def convert_to_np_float64_ndarray(tensor):
+        if isinstance(tensor, mindspore.Tensor):
+            ndarray = tensor.astype(mindspore.float64).numpy()
+        elif isinstance(tensor, torch.Tensor):
+            ndarray = tensor.to(torch.float64, copy=True).numpy()
+        else:
+            err_msg = "BaseCompareAlgorithm.convert_to_np_float64_ndarray failed: " \
+                "input is not mindspore.Tensor or torch.Tensor"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+        return ndarray
+
+    @staticmethod
+    def check_two_tensor(bench_compute_element, tested_compute_element):
+        bench_parameter = bench_compute_element.get_parameter()
+        tested_parameter = tested_compute_element.get_parameter()
+
+        bench_is_tensor = isinstance(bench_parameter, (mindspore.Tensor, torch.Tensor))
+        tested_is_tensor = isinstance(tested_parameter, (mindspore.Tensor, torch.Tensor))
+        shape_same = bench_compute_element.get_shape() == tested_compute_element.get_shape()
+        return bench_is_tensor and tested_is_tensor and shape_same
+
+    @abstractmethod
+    def check_validity(self, bench_compute_element, tested_compute_element):
+        '''
+        Args:
+            bench_compute_element: ComputeElement
+            tested_compute_element: ComputeElement
+
+        Return:
+            check_res: boolean
+        '''
+        raise NotImplementedError
+
+    @abstractmethod
+    def run_compare(self, bench_compute_element, tested_compute_element):
+        '''
+        Args:
+            bench_compute_element: ComputeElement
+            tested_compute_element: ComputeElement
+
+        Return:
+            compare_value: float/int
+        '''
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_pass(self, compare_value):
+        '''
+        Args:
+            compare_value: float/int
+
+        Return:
+            pass_status: str
+        '''
+        raise NotImplementedError
+
+
+class CosineSimilarityCompareAlgorithm(BaseCompareAlgorithm):
+    def __init__(self) -> None:
+        super().__init__()
+        self.compare_algorithm_name = CompareConst.COSINE
+
+    def check_validity(self, bench_compute_element, tested_compute_element):
+        return self.check_two_tensor(bench_compute_element, tested_compute_element)
+
+    def run_compare(self, bench_compute_element, tested_compute_element):
+        bench_ndarray = self.convert_to_np_float64_ndarray(bench_compute_element.get_parameter())
+        tested_ndarray = self.convert_to_np_float64_ndarray(tested_compute_element.get_parameter())
+
+        bench_norm = np.linalg.norm(bench_ndarray)
+        tested_norm = np.linalg.norm(tested_ndarray)
+        dot_product = np.dot(bench_ndarray.flatten(), tested_ndarray.flatten())
+        cosine_similarity = (MsCompareConst.EPSILON + dot_product) / (MsCompareConst.EPSILON + bench_norm * tested_norm)
+        return cosine_similarity
+
+    def check_pass(self, compare_value):
+        if compare_value > CompareConst.COS_THRESHOLD:
+            return CompareConst.PASS
+        else:
+            return CompareConst.ERROR
+
+
+class MaxAbsoluteDiffCompareAlgorithm(BaseCompareAlgorithm):
+    def __init__(self) -> None:
+        super().__init__()
+        self.compare_algorithm_name = CompareConst.MAX_ABS_ERR
+
+    def check_validity(self, bench_compute_element, tested_compute_element):
+        return self.check_two_tensor(bench_compute_element, tested_compute_element)
+
+    def run_compare(self, bench_compute_element, tested_compute_element):
+        bench_ndarray = self.convert_to_np_float64_ndarray(bench_compute_element.get_parameter())
+        tested_ndarray = self.convert_to_np_float64_ndarray(tested_compute_element.get_parameter())
+
+        max_absolute_diff = np.max(np.abs(bench_ndarray - tested_ndarray))
+        return max_absolute_diff
+
+    def check_pass(self, compare_value):
+        if compare_value < CompareConst.MAX_ABS_ERR_THRESHOLD:
+            return CompareConst.PASS
+        else:
+            return CompareConst.ERROR
+
+
+class MaxRelativeDiffCompareAlgorithm(BaseCompareAlgorithm):
+    def __init__(self) -> None:
+        super().__init__()
+        self.compare_algorithm_name = CompareConst.MAX_RELATIVE_ERR
+
+    def check_validity(self, bench_compute_element, tested_compute_element):
+        return self.check_two_tensor(bench_compute_element, tested_compute_element)
+
+    def run_compare(self, bench_compute_element, tested_compute_element):
+        bench_ndarray = self.convert_to_np_float64_ndarray(bench_compute_element.get_parameter())
+        tested_ndarray = self.convert_to_np_float64_ndarray(tested_compute_element.get_parameter())
+
+        abs_diff = np.abs(bench_ndarray - tested_ndarray)
+        bench_ndarray_nonzero = np.abs(bench_ndarray) + (bench_ndarray == 0) * MsCompareConst.EPSILON
+        max_relative_diff = np.max(abs_diff / bench_ndarray_nonzero)
+        return max_relative_diff
+
+    def check_pass(self, compare_value):
+        if compare_value < CompareConst.MAX_RELATIVE_ERR_THRESHOLD:
+            return CompareConst.PASS
+        else:
+            return CompareConst.ERROR
+
+
+
+compare_algorithms = {
+    CompareConst.COSINE: CosineSimilarityCompareAlgorithm(),
+    CompareConst.MAX_ABS_ERR: MaxAbsoluteDiffCompareAlgorithm(),
+    CompareConst.MAX_RELATIVE_ERR: MaxRelativeDiffCompareAlgorithm(),
+}

msprobe/mindspore/api_accuracy_checker/cmd_parser.py

@@ -0,0 +1,6 @@
+def add_api_accuracy_checker_argument(parser):
+    parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", type=str, required=True,
+                        help="<Required> The api param tool result file: generate from api param tool, "
+                             "a json file.")
+    parser.add_argument("-o", "--out_path", dest="out_path", default="./", type=str, required=False,
+                        help="<optional> The ut task result out path.")

msprobe/mindspore/api_accuracy_checker/compute_element.py

@@ -0,0 +1,239 @@
+import os
+
+import mindspore
+import torch
+import numpy as np
+
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.core.common.file_utils import load_npy
+from msprobe.mindspore.api_accuracy_checker.type_mapping import (dtype_str_to_np_dtype, api_info_type_str_to_type,
+                                                                 ms_dtype_to_dtype_str, torch_dtype_to_dtype_str,
+                                                                 dtype_str_to_ms_dtype, dtype_str_to_np_dtype,
+                                                                 dtype_str_to_torch_dtype, type_to_api_info_type_str,
+                                                                 DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE, TUPLE_TYPE_STR,
+                                                                 MINDSPORE_TENSOR_TYPE_STR, float_dtype_str_list,
+                                                                 int_dtype_str_list)
+from msprobe.core.common.const import Const
+from msprobe.mindspore.api_accuracy_checker.utils import check_and_get_from_json_dict, global_context
+
+
+class MstensorMetaData:
+    def __init__(self, dtype_str, npy_path, maximum, minimum, shape) -> None:
+        self.dtype_str = dtype_str
+        self.npy_path = npy_path
+        self.maximum = maximum
+        self.minimum = minimum
+        self.shape = shape
+
+class ComputeElement:
+    def __init__(self, compute_element_info=None, parameter=None):
+        self.supported_parameter_type = tuple(type_to_api_info_type_str.keys()) + tuple([torch.Tensor, tuple])
+        if parameter is not None:
+            self._init_with_parameter(parameter)
+        elif isinstance(compute_element_info, (list, dict)):
+            self._init_from_compute_element_info(compute_element_info)
+        elif compute_element_info is None:
+            self._init_from_null_compute_element_info()
+        else:
+            logger.error_log_with_exp(
+                "ComputeElement.__init__ failed: not init with parameter or compute_element info is not (list, dict)",
+                ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+
+    @staticmethod
+    def transfer_to_torch_tensor(ms_tensor):
+        '''
+        Args:
+            ms_tensor: mindspore.Tensor
+        Return:
+            torch_tensor: torch.Tensor
+        '''
+        ms_dtype = ms_tensor.dtype
+        dtype_str = ms_dtype_to_dtype_str.get(ms_dtype)
+        if dtype_str not in dtype_str_to_torch_dtype:
+            err_msg = f"ComputeElement.transfer_to_torch_tensor failed: no matching torch dtype for {dtype_str}"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+        else:
+            torch_dtype = dtype_str_to_torch_dtype.get(dtype_str)
+
+        if dtype_str in float_dtype_str_list:
+            middle_dtype = mindspore.float64
+        elif dtype_str in int_dtype_str_list:
+            middle_dtype = mindspore.int64
+        else:
+            middle_dtype = mindspore.uint64
+        np_ndarray = ms_tensor.astype(middle_dtype).numpy()
+        torch_tensor = torch.from_numpy(np_ndarray).to(torch_dtype)
+        return torch_tensor
+
+    @staticmethod
+    def transfer_to_mindspore_tensor(torch_tensor):
+        '''
+        Args:
+            torch_tensor: torch.Tensor
+
+        Return:
+            ms_tensor: mindspore.Tensor
+        '''
+        torch_dtype = torch_tensor.dtype
+        dtype_str = torch_dtype_to_dtype_str.get(torch_dtype)
+        if dtype_str not in dtype_str_to_ms_dtype:
+            err_msg = \
+                f"ComputeElement._transfer_to_mindspore_tensor failed: no matching mindspore dtype for {dtype_str}"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+        else:
+            ms_dtype = dtype_str_to_ms_dtype.get(dtype_str)
+
+        if dtype_str in float_dtype_str_list:
+            middle_dtype = torch.float64
+        elif dtype_str in int_dtype_str_list:
+            middle_dtype = torch.int64
+        np_ndarray = torch_tensor.to(middle_dtype, copy=True).numpy()
+        ms_tensor = mindspore.Tensor.from_numpy(np_ndarray).astype(ms_dtype)
+        return ms_tensor
+
+    @staticmethod
+    def convert_inf_to_real_num(value, dtype_str):
+        if value == float("inf"):
+            np_dtype = dtype_str_to_np_dtype.get(dtype_str, DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE)
+            value = np.finfo(np_dtype).max
+        elif value == float("-inf"):
+            np_dtype = dtype_str_to_np_dtype.get(dtype_str, DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE)
+            value = np.finfo(np_dtype).min
+        return value
+
+    def get_parameter(self, get_origin=True, tensor_platform=Const.MS_FRAMEWORK):
+        '''
+        Args:
+            get_origin: boolean
+            tensor_platform: str, Union["mindspore", "pytorch"]
+
+        Return:
+            parameter: Union[int, float, str, slice, tuple, torch.Tensor, mindspore.Tensor]
+        '''
+        if self.parameter is None:
+            return self.parameter
+        if isinstance(self.parameter, tuple):
+            return tuple([compute_element.get_parameter(get_origin=get_origin, tensor_platform=tensor_platform)
+                          for compute_element in self.parameter])
+        elif isinstance(self.parameter, self.supported_parameter_type):
+            parameter_tmp = self.parameter
+        elif isinstance(self.parameter, MstensorMetaData):
+            mstensor_meta_data = self.parameter
+            ms_dtype = dtype_str_to_ms_dtype.get(mstensor_meta_data.dtype_str)
+            if global_context.get_is_constructed():
+                np_dtype = dtype_str_to_np_dtype.get(mstensor_meta_data.dtype_str, DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE)
+                ndarray = self._construct_ndarray(mstensor_meta_data.shape, mstensor_meta_data.maximum,
+                                                  mstensor_meta_data.minimum, np_dtype)
+            else:
+                ndarray = load_npy(mstensor_meta_data.npy_path)
+            parameter_tmp = mindspore.Tensor(ndarray, dtype=ms_dtype)
+        else:
+            err_msg = "ComputeElement.get_parameter failed: self.parameter type is not in " \
+                "(int, float, str, slice, bool, torch.Tensor, mindspore.Tensor, MstensorMetaData)"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+
+        # if necessary, do transfer
+        if not get_origin and isinstance(parameter_tmp, mindspore.Tensor) and tensor_platform == Const.PT_FRAMEWORK:
+            parameter = self.transfer_to_torch_tensor(parameter_tmp)
+        elif not get_origin and isinstance(parameter_tmp, torch.Tensor) and tensor_platform ==Const.MS_FRAMEWORK:
+            parameter = self.transfer_to_mindspore_tensor(parameter_tmp)
+        else:
+            parameter = parameter_tmp
+
+        return parameter
+
+    def get_shape(self):
+        return self.shape
+
+    def get_dtype(self):
+        return self.dtype_str
+
+    def _construct_ndarray(self, shape, maximum, minimum, np_dtype):
+        shape = tuple(shape)
+        np.random.seed(42)
+        if np_dtype == np.bool_:
+            ndarray = np.random.rand(*shape) > 0.5
+        else:
+            maximum = self.convert_inf_to_real_num(maximum, np_dtype)
+            minimum = self.convert_inf_to_real_num(minimum, np_dtype)
+            ndarray = np.random.uniform(minimum, maximum, shape).astype(np_dtype)
+        return ndarray
+
+    def _init_from_null_compute_element_info(self):
+        self.parameter = None
+        self.shape = tuple()
+        self.dtype = "None"
+
+    def _init_from_compute_element_info(self, compute_element_info):
+        '''
+        Args:
+            compute_element_info: Union[list, dict]
+
+        Return:
+            void
+
+        init member attributes: self.shape, self.dtype_str, self.parameter
+        '''
+        if isinstance(compute_element_info, list):
+            self.shape = tuple()
+            self.dtype_str = TUPLE_TYPE_STR
+            self.parameter = tuple([ComputeElement(compute_element_info=sub_info)
+                                    for sub_info in compute_element_info])
+        else:
+            type_str = check_and_get_from_json_dict(compute_element_info, "type", "type field in api_info.json",
+                                                    accepted_type=str, accepted_value=api_info_type_str_to_type.keys())
+
+            if type_str == MINDSPORE_TENSOR_TYPE_STR:
+                self._init_from_mstensor_compute_element_info(compute_element_info)
+            else: # type_str in ("slice", "int", "float", "bool")
+                value = check_and_get_from_json_dict(compute_element_info, "value", "value field in api_info.json")
+                self.shape = tuple()
+                self.dtype_str = type_str
+                self.parameter = slice(*tuple(value)) if type_str == "slice" else value
+
+    def _init_from_mstensor_compute_element_info(self, compute_element_info):
+        '''
+            do not load real tensor, only record meta data
+        '''
+        dtype_str = check_and_get_from_json_dict(compute_element_info, "dtype", "dtype field in api_info.json",
+                                            accepted_type=str, accepted_value=dtype_str_to_ms_dtype.keys())
+        shape = check_and_get_from_json_dict(compute_element_info, "shape", "shape field in api_info.json",
+                                                accepted_type=(list,))
+        if global_context.get_is_constructed():
+            maximum = check_and_get_from_json_dict(compute_element_info, "Max", "Max field in api_info.json",
+                                                    accepted_type=(int, float))
+            minimum = check_and_get_from_json_dict(compute_element_info, "Min", "Min field in api_info.json",
+                                                accepted_type=(int, float))
+
+            npy_path = None
+        else:
+            maximum, minimum = None, None
+            data_name = check_and_get_from_json_dict(compute_element_info, "data_name",
+                                                "data_name field in api_info.json", accepted_type=(str,))
+            npy_path = os.path.join(global_context.get_dump_data_dir(), data_name)
+        mstensor_meta_data = MstensorMetaData(dtype_str, npy_path, maximum, minimum, shape)
+        self.parameter = mstensor_meta_data
+        self.dtype_str = dtype_str
+        self.shape = tuple(shape)
+
+    def _init_with_parameter(self, parameter):
+        self.parameter = parameter
+        if not isinstance(parameter, self.supported_parameter_type):
+            err_msg = "ComputeElement._init_with_parameter failed: " \
+                "parameter type is not in (int, float, str, slice, bool, torch.Tensor, mindspore.Tensor)"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
+        if isinstance(parameter, mindspore.Tensor):
+            self.shape = tuple(parameter.shape)
+            self.dtype_str = ms_dtype_to_dtype_str.get(parameter.dtype)
+        elif isinstance(parameter, torch.Tensor):
+            self.shape = tuple(parameter.shape)
+            self.dtype_str = torch_dtype_to_dtype_str.get(parameter.dtype)
+        elif isinstance(parameter, tuple):
+            self.shape = tuple()
+            self.dtype_str = TUPLE_TYPE_STR
+            self.parameter = tuple([ComputeElement(parameter=param) for param in parameter])
+        else:
+            self.shape = tuple()
+            self.dtype_str = \
+                TUPLE_TYPE_STR if isinstance(parameter, tuple) else type_to_api_info_type_str.get(type(parameter))

msprobe/mindspore/api_accuracy_checker/main.py

@@ -0,0 +1,9 @@
+from msprobe.mindspore.api_accuracy_checker.api_accuracy_checker import ApiAccuracyChecker
+
+
+def api_checker_main(args):
+    api_accuracy_checker = ApiAccuracyChecker()
+    api_accuracy_checker.parse(args.api_info_file)
+    api_accuracy_checker.run_and_compare()
+    api_accuracy_checker.to_detail_csv(args.out_path)
+    api_accuracy_checker.to_result_csv(args.out_path)

msprobe/mindspore/api_accuracy_checker/type_mapping.py

@@ -0,0 +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,
+]

msprobe/mindspore/api_accuracy_checker/utils.py

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,34 @@
+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