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

msprobe/mindspore/api_accuracy_checker/api_runner.py

@@ -0,0 +1,152 @@
+
+
+import mindspore
+import torch
+from mindspore import ops
+
+from msprobe.mindspore.api_accuracy_checker.compute_element import ComputeElement
+from msprobe.core.common.const import Const, MsCompareConst
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.core.common.log import logger
+from msprobe.mindspore.api_accuracy_checker.utils import convert_to_tuple
+
+
+class ApiInputAggregation:
+    def __init__(self, inputs, kwargs, gradient_inputs) -> None:
+        '''
+        Args:
+            inputs: List[ComputeElement]
+            kwargs: dict{str: ComputeElement}
+            gradient_inputs: Union[List[ComputeElement], None]
+        '''
+        self.inputs = inputs
+        self.kwargs = kwargs
+        self.gradient_inputs = gradient_inputs
+
+api_parent_module_mapping = {
+    (MsCompareConst.MINT, Const.MS_FRAMEWORK): mindspore.mint,
+    (MsCompareConst.MINT, Const.PT_FRAMEWORK): torch,
+    (MsCompareConst.MINT_FUNCTIONAL, Const.MS_FRAMEWORK): mindspore.mint.nn.functional,
+    (MsCompareConst.MINT_FUNCTIONAL, Const.PT_FRAMEWORK): torch.nn.functional
+}
+
+class ApiRunner:
+    def __call__(self, api_input_aggregation, api_name_str, forward_or_backward=Const.FORWARD,
+                 api_platform=Const.MS_FRAMEWORK):
+        '''
+        Args:
+            api_input_aggregation: ApiInputAggregation
+            api_name_str: str, e.g. "MintFunctional.relu.0"
+            forward_or_backward: str, Union["forward", "backward"]
+            api_platform: str, Union["mindspore", "torch"]
+
+        Return:
+            outputs: list[ComputeElement]
+
+        Description:
+            run mindspore.mint/torch api
+        '''
+        api_type_str, api_sub_name = self.get_info_from_name(api_name_str)
+        api_instance = self.get_api_instance(api_type_str, api_sub_name, api_platform)
+
+        return self.run_api(api_instance, api_input_aggregation, forward_or_backward, api_platform)
+
+    @staticmethod
+    def get_info_from_name(api_name_str):
+        '''
+        Args:
+            api_name_str: str, the trimmed key of data dict in api_info.json. e.g. "MintFunctional.relu.0"
+
+        Return:
+            api_type_str: str, Union["MintFunctional", "Mint"]
+            api_sub_name: str, e.g. "relu"
+        '''
+        api_name_list = api_name_str.split(Const.SEP)
+        if len(api_name_list) != 3:
+            err_msg = f"ApiRunner.get_info_from_name failed: api_name_str: {api_name_str} is not in defined format"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.WrongValue))
+        api_type_str, api_sub_name = api_name_list[0], api_name_list[1]
+        if api_type_str not in [MsCompareConst.MINT, MsCompareConst.MINT_FUNCTIONAL]:
+            err_msg = f"ApiRunner.get_info_from_name failed: not mint or mint.nn.functional api"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.WrongValue))
+
+        return api_type_str, api_sub_name
+
+    @staticmethod
+    def get_api_instance(api_type_str, api_sub_name, api_platform):
+        '''
+        Args:
+            api_type_str: str, Union["MintFunctional", "Mint"]
+            api_sub_name: str, e.g. "relu"
+            api_platform: str: Union["mindpore", "torch"]
+
+        Return:
+            api_instance: function object
+
+        Description:
+            get mindspore.mint/torch api fucntion
+            mindspore.mint.{api_sub_name} <--> torch.{api_sub_name}
+            mindspore.mint.nn.functional.{api_sub_name} <--> torch.nn.functional.{api_sub_name}
+        '''
+
+        api_parent_module = api_parent_module_mapping.get((api_type_str, api_platform))
+        module_str = "mindspore.mint." if api_platform == Const.MS_FRAMEWORK else "torch."
+        submodule_str = "nn.functional." if api_type_str == MsCompareConst.MINT_FUNCTIONAL else ""
+        full_api_name = module_str + submodule_str + api_sub_name
+        if not hasattr(api_parent_module, api_sub_name):
+            err_msg = f"ApiRunner.get_api_instance failed: {full_api_name} is not found"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.ApiWrong))
+
+        api_instance = getattr(api_parent_module, api_sub_name)
+        if not callable(api_instance):
+            err_msg = f"ApiRunner.get_api_instance failed: {full_api_name} is not callable"
+            logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.ApiWrong))
+
+        return api_instance
+
+    @staticmethod
+    def run_api(api_instance, api_input_aggregation, forward_or_backward, api_platform):
+        inputs = tuple(compute_element.get_parameter(get_origin=False, tensor_platform=api_platform)
+                       for compute_element in api_input_aggregation.inputs)
+        kwargs = {key: value.get_parameter(get_origin=False, tensor_platform=api_platform)
+                  for key, value in api_input_aggregation.kwargs.items()}
+        gradient_inputs = api_input_aggregation.gradient_inputs
+
+        if forward_or_backward == Const.FORWARD:
+            forward_result = api_instance(*inputs, **kwargs) # can be single tensor or tuple
+            forward_result_tuple = convert_to_tuple(forward_result)
+            res_compute_element_list = [ComputeElement(parameter=api_res) for api_res in forward_result_tuple]
+        else:
+            if gradient_inputs is None:
+                err_msg = f"ApiRunner.run_api failed: run backward api but gradient_inputs is missing"
+                logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.WrongValue))
+            gradient_inputs = tuple(compute_element.get_parameter(get_origin=False, tensor_platform=api_platform)
+                                    for compute_element in gradient_inputs)
+            if api_platform == Const.MS_FRAMEWORK:
+                if len(gradient_inputs) == 1:
+                    gradient_inputs = gradient_inputs[0]
+                def api_with_kwargs(*forward_inputs):
+                    return api_instance(*forward_inputs, **kwargs)
+                grad_func = ops.GradOperation(get_all=True, sens_param=True)(api_with_kwargs)
+                backward_result = grad_func(*inputs, gradient_inputs) # can be single tensor or tuple
+                backward_result_tuple = convert_to_tuple(backward_result)
+                res_compute_element_list = [ComputeElement(parameter=api_res) for api_res in backward_result_tuple]
+            else:
+                #set requires_grad
+                for tensor in inputs:
+                    if hasattr(tensor, "requires_grad"):
+                        setattr(tensor, "requires_grad", True)
+                forward_results = api_instance(*inputs, **kwargs)
+                forward_results = convert_to_tuple(forward_results)
+                for forward_res, gradient_in in zip(forward_results, gradient_inputs):
+                    forward_res.backward(gradient_in)
+                backward_result_list = []
+                for tensor in inputs:
+                    if hasattr(tensor, "grad"):
+                        backward_result_list.append(getattr(tensor, "grad"))
+                res_compute_element_list = [ComputeElement(parameter=api_res) for api_res in backward_result_list]
+
+        return res_compute_element_list
+
+
+api_runner = ApiRunner()

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.core.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/compute_element.py

@@ -0,0 +1,224 @@
+import os
+
+import mindspore
+import torch
+import numpy as np
+
+from msprobe.core.common.log import logger
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.core.common.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)
+        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
+            get_mindspore_tensor: boolean
+
+        Return:
+            parameter: Union[int, float, str, slice,tuple,  torch.Tensor, mindspore.Tensor]
+        '''
+        if 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_compute_element_info(self, compute_element_info):
+        '''
+        Args:
+            compute_element_info: Union[list, dict]
+            is_constructed: boolean
+
+        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).get_parameter()
+                                   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)
+        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,16 @@
+from msprobe.mindspore.api_accuracy_checker.api_accuracy_checker import ApiAccuracyChecker
+
+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.")
+
+
+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)