mindstudio-probe 1.1.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

msprobe/msprobe.py

@@ -16,10 +16,12 @@
 import argparse
 import sys
 import importlib.util
-from msprobe.core.compare.utils import _compare_parser
+
+from msprobe.core.common.const import Const
 from msprobe.core.common.log import logger
+from msprobe.core.compare.utils import _compare_parser
 from msprobe.core.compare.compare_cli import compare_cli
-from msprobe.core.common.const import Const
+from msprobe.core.compare.merge_result.merge_result_cli import _merge_result_parser, merge_result_cli
 
 
 def is_module_available(module_name):
@@ -45,10 +47,15 @@ def main():
     multi_run_ut_cmd_parser = subparsers.add_parser('multi_run_ut')
     api_precision_compare_cmd_parser = subparsers.add_parser('api_precision_compare')
     run_overflow_check_cmd_parser = subparsers.add_parser('run_overflow_check')
+    code_mapping_cmd_parser = subparsers.add_parser('code_mapping')
     graph_service_cmd_parser = subparsers.add_parser('graph')
+    op_generate_cmd_parser = subparsers.add_parser('op_generate')
+    merge_result_parser = subparsers.add_parser('merge_result')
     _compare_parser(compare_cmd_parser)
+    _merge_result_parser(merge_result_parser)
+
     is_torch_available = is_module_available("torch")
-    is_mindspore_available = is_module_available("mindspore")
+
     if len(sys.argv) < 4:
         parser.print_help()
         sys.exit(0)
@@ -62,6 +69,8 @@ def main():
         from msprobe.pytorch.api_accuracy_checker.run_ut.run_overflow_check import _run_overflow_check_parser, \
             _run_overflow_check_command
         from msprobe.visualization.graph_service import _pt_graph_service_parser, _pt_graph_service_command
+        from msprobe.pytorch.api_accuracy_checker.generate_op_script.op_generator import _op_generator_parser, \
+            _run_operator_generate_commond
 
         _run_ut_parser(run_ut_cmd_parser)
         _run_ut_parser(multi_run_ut_cmd_parser)
@@ -70,12 +79,15 @@ def main():
         _api_precision_compare_parser(api_precision_compare_cmd_parser)
         _run_overflow_check_parser(run_overflow_check_cmd_parser)
         _pt_graph_service_parser(graph_service_cmd_parser)
+        _op_generator_parser(op_generate_cmd_parser)
     elif framework_args.framework == Const.MS_FRAMEWORK:
         from msprobe.mindspore.api_accuracy_checker.cmd_parser import add_api_accuracy_checker_argument
         from msprobe.visualization.graph_service import _ms_graph_service_parser, _ms_graph_service_command
         add_api_accuracy_checker_argument(run_ut_cmd_parser)
         from msprobe.mindspore.api_accuracy_checker.cmd_parser import multi_add_api_accuracy_checker_argument
         multi_add_api_accuracy_checker_argument(multi_run_ut_cmd_parser)
+        from msprobe.mindspore.code_mapping.cmd_parser import add_ir_parser_arguments
+        add_ir_parser_arguments(code_mapping_cmd_parser)
 
         _ms_graph_service_parser(graph_service_cmd_parser)
 
@@ -97,17 +109,23 @@ def main():
             _run_overflow_check_command(args)
         elif sys.argv[3] == "graph":
             _pt_graph_service_command(args)
+        elif sys.argv[3] == 'op_generate':
+            _run_operator_generate_commond(args)
         elif sys.argv[3] == "compare":
             if args.cell_mapping is not None or args.api_mapping is not None:
                 logger.error("Argument -cm or -am is not supported in PyTorch framework")
                 raise Exception("Argument -cm or -am is not supported in PyTorch framework")
             compare_cli(args)
+        elif sys.argv[3] == "merge_result":
+            merge_result_cli(args)
     else:
         if not is_module_available(Const.MS_FRAMEWORK):
             logger.error("MindSpore does not exist, please install MindSpore library")
             raise Exception("MindSpore does not exist, please install MindSpore library")
         if sys.argv[3] == "compare":
             compare_cli(args)
+        elif sys.argv[3] == "merge_result":
+            merge_result_cli(args)
         elif sys.argv[3] == "run_ut":
             from msprobe.mindspore.api_accuracy_checker.main import api_checker_main
             api_checker_main(args)
@@ -116,6 +134,9 @@ def main():
             mul_api_checker_main(args)
         elif sys.argv[3] == "graph":
             _ms_graph_service_command(args)
+        elif sys.argv[3] == "code_mapping":
+            from msprobe.mindspore.code_mapping.main import code_mapping_main
+            code_mapping_main(args)
 
 
 if __name__ == "__main__":

msprobe/pytorch/__init__.py

@@ -1,6 +1,4 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
 # All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0  (the "License");
@@ -15,10 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-from msprobe.pytorch.monitor.module_hook import TrainerMon
+import torch
 from .compare.distributed_compare import compare_distributed
 from .compare.pt_compare import compare
 from .common.utils import seed_all
-from .debugger.precision_debugger import PrecisionDebugger
-from .functional.module_dump import module_dump, module_dump_end
+from .debugger.precision_debugger import PrecisionDebugger, module_dump, module_dump_end
+
+torch_version_above_or_equal_2 = torch.__version__.split('+')[0] >= '2.0'
+if torch_version_above_or_equal_2:
+    from msprobe.pytorch.monitor.module_hook import TrainerMon

msprobe/pytorch/api_accuracy_checker/common/utils.py

@@ -72,38 +72,53 @@ def check_need_convert(api_name):
     return convert_type
 
 
-def api_info_preprocess(api_name, api_info_dict):
+def cross_entropy_process(api_info_dict):
     """
     Function Description:
-        Preprocesses the API information.
+        Preprocesses the cross_entropy API information.
     Parameter:
-        api_name: Name of the API.
         api_info_dict: argument of the API.
     Return api_info_dict:
-        convert_type: Type of conversion.
         api_info_dict: Processed argument of the API.
     """
-    convert_type = check_need_convert(api_name)
-    if api_name == 'cross_entropy':
-        api_info_dict = cross_entropy_process(api_info_dict)
-    return convert_type, api_info_dict
+    if 'input_args' in api_info_dict and len(api_info_dict['input_args']) > 1 \
+        and 'Min' in api_info_dict['input_args'][1]:
+        if api_info_dict['input_args'][1]['Min'] <= 0:
+            # The second argument in cross_entropy should be -100 or not less than 0
+            api_info_dict['input_args'][1]['Min'] = 0
+    return api_info_dict
 
 
-def cross_entropy_process(api_info_dict):
+def histc_process(api_info_dict):
+    input_args = api_info_dict['input_args']
+    if input_args and input_args[0].get('dtype'):
+        dtype = input_args[0]['dtype']
+        if dtype in Const.TORCH_INT_DTYPE:
+            api_info_dict['input_args'][0]['dtype'] = Const.TORCH_FLOAT32
+    return api_info_dict
+
+
+API_PROCESS_MAP = {
+    'cross_entropy': cross_entropy_process,
+    'histc': histc_process
+}
+
+
+def api_info_preprocess(api_name, api_info_dict):
     """
     Function Description:
-        Preprocesses the cross_entropy API information.
+        Preprocesses the API information.
     Parameter:
+        api_name: Name of the API.
         api_info_dict: argument of the API.
     Return api_info_dict:
+        convert_type: Type of conversion.
         api_info_dict: Processed argument of the API.
     """
-    if 'input_args' in api_info_dict and len(api_info_dict['input_args']) > 1 \
-        and 'Min' in api_info_dict['input_args'][1]:
-        if api_info_dict['input_args'][1]['Min'] <= 0:
-            # The second argument in cross_entropy should be -100 or not less than 0
-            api_info_dict['input_args'][1]['Min'] = 0
-    return api_info_dict
+    convert_type = check_need_convert(api_name)
+    if api_name in API_PROCESS_MAP:
+        api_info_dict = API_PROCESS_MAP[api_name](api_info_dict)
+    return convert_type, api_info_dict
 
 
 def initialize_save_path(save_path, dir_name):

msprobe/pytorch/api_accuracy_checker/compare/algorithm.py

@@ -16,10 +16,12 @@
 # limitations under the License.
 
 # 定义比对算法及比对标准
+import math
 import torch
 import numpy as np
 
 from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import ULP_PARAMETERS
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_config import StandardConfig
 from msprobe.core.common.const import CompareConst
 
 
@@ -179,13 +181,13 @@ def check_inf_nan_value(inf_nan_mask, bench_output, device_output, dtype, rtol):
 
 def check_small_value(abs_err, small_value_mask, small_value_atol):
     '''
-    新精度标准的相对阈值法中，检查npu和golden小值域输出的相对误差是否满足阈值
+    新精度标准的绝对阈值法中，检查npu和golden正常值输出的绝对误差是否满足阈值
     输入：
-        rel_err：npu输出和golden输出的相对误差
+        abs_err：npu输出和golden输出的绝对误差
         normal_value_mask：npu输出和golden输出的正常值mask
-        rtol：相对误差的阈值
+        atol：绝对误差的阈值
     输出： 
-        rel_err_ratio：npu输出和golden输出的相对误差不满足阈值的比例
+        abs_err_ratio：npu输出和golden输出的绝对误差不满足阈值的比例
     '''
     greater_mask = np.greater(abs_err, small_value_atol)
     err_mask = np.logical_and(greater_mask, small_value_mask)
@@ -195,13 +197,13 @@ def check_small_value(abs_err, small_value_mask, small_value_atol):
 
 def check_norm_value(normal_value_mask, rel_err, rtol):
     '''
-    新精度标准的绝对阈值法中，检查npu和golden正常值输出的绝对误差是否满足阈值
+    新精度标准的相对阈值法中，检查npu和golden小值域输出的相对误差是否满足阈值
     输入：
-        abs_err：npu输出和golden输出的绝对误差
+        rel_err：npu输出和golden输出的相对误差
         normal_value_mask：npu输出和golden输出的正常值mask
-        atol：绝对误差的阈值
+        rtol：相对误差的阈值
     输出： 
-        abs_err_ratio：npu输出和golden输出的绝对误差不满足阈值的比例
+        rel_err_ratio：npu输出和golden输出的相对误差不满足阈值的比例
     '''
     err_mask = np.greater(rel_err, rtol)
     err_mask = np.logical_and(err_mask, normal_value_mask)
@@ -228,3 +230,34 @@ def get_ulp_err(bench_output, device_output, dtype):
 def calc_ulp_err(bench_output, device_output, eb, exponent_num, data_type):
     return (device_output.astype(data_type) - bench_output).astype(data_type) * \
             np.exp2(-eb + exponent_num).astype(data_type)
+
+
+def calc_ratio(x, y, dtype):
+    """
+    Calculate the ratio between NPU and GPU statistical values.
+
+    Args:
+        x (float): Statistical value from the NPU side
+        y (float): Statistical value from the GPU side
+        dtype: Data type used to determine the minimum error value
+
+    Returns:
+        float: The ratio of NPU to GPU statistical values
+
+    Notes:
+        - Takes absolute values of both x and y for calculation
+        - Uses StandardConfig.get_minmum_err(dtype) to get minimum error for the specified dtype
+        - Prevents division by zero by ensuring denominator is not less than minimum error
+        - Returns |x| / max(|y|, minimum_error)
+    """
+    x, y = abs(x), abs(y)
+    minmum_err = StandardConfig.get_minmum_err(dtype)
+    err_y = max(y, minmum_err)
+    return x / err_y
+
+
+def compare_bool_tensor(bench_output, device_output):
+    error_nums = (bench_output != device_output).sum()
+    error_rate = float(error_nums / bench_output.size)
+    result = CompareConst.PASS if error_rate == 0 else CompareConst.ERROR
+    return error_rate, result, ""