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

msprobe/mindspore/api_accuracy_checker/api_info.py

@@ -1,69 +1,69 @@
-from msprobe.mindspore.api_accuracy_checker.compute_element import ComputeElement
-from msprobe.core.common.const import Const
-from msprobe.mindspore.api_accuracy_checker.utils import check_and_get_from_json_dict
-from msprobe.core.common.exceptions import ApiAccuracyCheckerException
-from msprobe.core.common.log import logger
-
-class ApiInfo:
-    def __init__(self, api_name):
-        self.api_name = api_name
-        self.forward_info = None
-        self.backward_info = None
-
-    def load_forward_info(self, forward_info_dict):
-        self.forward_info = forward_info_dict
-
-    def load_backward_info(self, backward_info_dict):
-        self.backward_info = backward_info_dict
-
-    def check_forward_info(self):
-        return self.forward_info is not None
-
-    def check_backward_info(self):
-        return self.backward_info is not None
-
-    def get_compute_element_list(self, forward_or_backward, input_or_output):
-        '''
-        Args:
-            forward_or_backward: str, Union["forward", "backward"]
-            input_or_output: str,  Union["input", "output"]
-
-        Return:
-            compute_element_list: List[ComputeElement]
-        '''
-        mapping = {
-            (Const.FORWARD, Const.INPUT): [self.forward_info, Const.INPUT_ARGS,
-                                           f"input_args field of {self.api_name} forward api in api_info.json"],
-            (Const.FORWARD, Const.OUTPUT): [self.forward_info, Const.OUTPUT,
-                                            f"output field of {self.api_name} forward api in api_info.json"],
-            (Const.BACKWARD, Const.INPUT): [self.backward_info, Const.INPUT,
-                                            f"input field of {self.api_name} backward api in api_info.json"],
-            (Const.BACKWARD, Const.OUTPUT): [self.backward_info, Const.OUTPUT,
-                                             f"output field of {self.api_name} backward api in api_info.json"]
-        }
-        dict_instance, key, key_desc = mapping.get((forward_or_backward, input_or_output))
-        compute_element_info_list = check_and_get_from_json_dict(dict_instance, key, key_desc, accepted_type=list)
-        compute_element_list = [ComputeElement(compute_element_info=compute_element_info)
-                                for compute_element_info in compute_element_info_list]
-        return compute_element_list
-
-    def get_kwargs(self):
-        '''
-        Return:
-            kwargs_compute_element_dict: dict{str: ComputeElement}
-        '''
-        kwargs_dict = check_and_get_from_json_dict(self.forward_info, Const.INPUT_KWARGS,
-                                                   "input_kwargs in api_info.json", accepted_type=dict)
-        for key_str, compute_element_info in kwargs_dict.items():
-            if not isinstance(key_str, str):
-                err_msg = "ApiInfo.get_kwargs failed: compute_element_dict key is not a string"
-                logger.error_log_with_exp(err_msg,
-                                          ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed))
-            if not isinstance(compute_element_info, (list, dict)):
-                err_msg = "ApiInfo.get_kwargs failed: compute_element_dict value is not a list or dict"
-                logger.error_log_with_exp(err_msg,
-                                          ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed))
-        kwargs_compute_element_dict = {key_str: ComputeElement(compute_element_info=compute_element_info)
-                                       for key_str, compute_element_info in kwargs_dict.items()}
-        return kwargs_compute_element_dict
-
+from msprobe.mindspore.api_accuracy_checker.compute_element import ComputeElement
+from msprobe.core.common.const import Const
+from msprobe.mindspore.api_accuracy_checker.utils import check_and_get_from_json_dict
+from msprobe.core.common.exceptions import ApiAccuracyCheckerException
+from msprobe.mindspore.common.log import logger
+
+class ApiInfo:
+    def __init__(self, api_name):
+        self.api_name = api_name
+        self.forward_info = None
+        self.backward_info = None
+
+    def load_forward_info(self, forward_info_dict):
+        self.forward_info = forward_info_dict
+
+    def load_backward_info(self, backward_info_dict):
+        self.backward_info = backward_info_dict
+
+    def check_forward_info(self):
+        return self.forward_info is not None
+
+    def check_backward_info(self):
+        return self.backward_info is not None
+
+    def get_compute_element_list(self, forward_or_backward, input_or_output):
+        '''
+        Args:
+            forward_or_backward: str, Union["forward", "backward"]
+            input_or_output: str,  Union["input", "output"]
+
+        Return:
+            compute_element_list: List[ComputeElement]
+        '''
+        mapping = {
+            (Const.FORWARD, Const.INPUT): [self.forward_info, Const.INPUT_ARGS,
+                                           f"input_args field of {self.api_name} forward api in api_info.json"],
+            (Const.FORWARD, Const.OUTPUT): [self.forward_info, Const.OUTPUT,
+                                            f"output field of {self.api_name} forward api in api_info.json"],
+            (Const.BACKWARD, Const.INPUT): [self.backward_info, Const.INPUT,
+                                            f"input field of {self.api_name} backward api in api_info.json"],
+            (Const.BACKWARD, Const.OUTPUT): [self.backward_info, Const.OUTPUT,
+                                             f"output field of {self.api_name} backward api in api_info.json"]
+        }
+        dict_instance, key, key_desc = mapping.get((forward_or_backward, input_or_output))
+        compute_element_info_list = check_and_get_from_json_dict(dict_instance, key, key_desc, accepted_type=list)
+        compute_element_list = [ComputeElement(compute_element_info=compute_element_info)
+                                for compute_element_info in compute_element_info_list]
+        return compute_element_list
+
+    def get_kwargs(self):
+        '''
+        Return:
+            kwargs_compute_element_dict: dict{str: ComputeElement}
+        '''
+        kwargs_dict = check_and_get_from_json_dict(self.forward_info, Const.INPUT_KWARGS,
+                                                   "input_kwargs in api_info.json", accepted_type=dict)
+        for key_str, compute_element_info in kwargs_dict.items():
+            if not isinstance(key_str, str):
+                err_msg = "ApiInfo.get_kwargs failed: compute_element_dict key is not a string"
+                logger.error_log_with_exp(err_msg,
+                                          ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed))
+            if not isinstance(compute_element_info, (list, dict)):
+                err_msg = "ApiInfo.get_kwargs failed: compute_element_dict value is not a list or dict"
+                logger.error_log_with_exp(err_msg,
+                                          ApiAccuracyCheckerException(ApiAccuracyCheckerException.ParseJsonFailed))
+        kwargs_compute_element_dict = {key_str: ComputeElement(compute_element_info=compute_element_info)
+                                       for key_str, compute_element_info in kwargs_dict.items()}
+        return kwargs_compute_element_dict
+

msprobe/mindspore/api_accuracy_checker/api_runner.py

@@ -1,152 +1,156 @@
-
-
-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
-
-
+
+
+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.mindspore.common.log import logger
+from msprobe.mindspore.api_accuracy_checker.utils import convert_to_tuple
+from msprobe.mindspore.api_accuracy_checker.type_mapping import float_dtype_str_list, torch_dtype_to_dtype_str
+
+
+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
+                requires_grad_index = []
+                for index, tensor in enumerate(inputs):
+                    if isinstance(tensor, torch.Tensor) and \
+                        torch_dtype_to_dtype_str.get(tensor.dtype) in float_dtype_str_list:
+                        setattr(tensor, "requires_grad", True)
+                        requires_grad_index.append(index)
+                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 index in requires_grad_index:
+                    backward_result_list.append(getattr(inputs[index], "grad"))
+                res_compute_element_list = [ComputeElement(parameter=api_res) for api_res in backward_result_list]
+
+        return res_compute_element_list
+
+
 api_runner = ApiRunner()