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

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");
@@ -16,8 +14,12 @@
 # limitations under the License.
 
 
-from .debugger.precision_debugger import PrecisionDebugger
-from .common.utils import seed_all
+import torch
 from .compare.distributed_compare import compare_distributed
 from .compare.pt_compare import compare
-from .functional.module_dump import module_dump, module_dump_end
+from .common.utils import seed_all
+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/config.py

@@ -16,10 +16,18 @@
 # limitations under the License.
 
 import os
+from collections import namedtuple
 from msprobe.core.common.file_utils import load_yaml, check_file_or_directory_path
+from msprobe.core.common.utils import is_int
 from msprobe.pytorch.pt_config import RunUTConfig
 
 
+RunUtConfig = namedtuple('RunUtConfig', ['forward_content', 'backward_content', 'result_csv_path', 'details_csv_path',
+                                         'save_error_data', 'is_continue_run_ut', 'real_data_path', 'white_list',
+                                         'black_list', 'error_data_path', 'online_config'])
+OnlineConfig = namedtuple('OnlineConfig', ['is_online', 'nfs_path', 'host', 'port', 'rank_list', 'tls_path'])
+
+
 class Config:
     def __init__(self, yaml_file):
         check_file_or_directory_path(yaml_file, False)
@@ -50,6 +58,8 @@ class Config:
             raise ValueError(f"{key} must be one of {validators.keys()}")
         if not isinstance(value, validators.get(key)):
             raise ValueError(f"{key} must be {validators[key].__name__} type")
+        if key == 'precision' and not is_int(value):
+            raise ValueError("precision must be an integer")
         if key == 'precision' and (value < 0 or value > 20):
             raise ValueError("precision must be greater than or equal to 0 and less than 21")
         if key == 'white_list':
@@ -68,3 +78,55 @@ class Config:
 cur_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 yaml_path = os.path.join(cur_path, "config.yaml")
 msCheckerConfig = Config(yaml_path)
+
+
+class CheckerConfig:
+    def __init__(self, task_config=None):
+        self.white_list = msCheckerConfig.white_list
+        self.black_list = msCheckerConfig.black_list
+        self.error_data_path = msCheckerConfig.error_data_path
+        self.is_online = msCheckerConfig.is_online
+        self.nfs_path = msCheckerConfig.nfs_path
+        self.host = msCheckerConfig.host
+        self.port = msCheckerConfig.port
+        self.rank_list = msCheckerConfig.rank_list
+        self.tls_path = msCheckerConfig.tls_path
+
+        if task_config:
+            self.load_config(task_config)
+
+    def load_config(self, task_config):
+        self.white_list = task_config.white_list
+        self.black_list = task_config.black_list
+        self.error_data_path = task_config.error_data_path
+        self.is_online = task_config.is_online
+        self.nfs_path = task_config.nfs_path
+        self.host = task_config.host
+        self.port = task_config.port
+        self.rank_list = task_config.rank_list
+        self.tls_path = task_config.tls_path
+    
+    def get_online_config(self):
+        return OnlineConfig(
+            is_online=self.is_online,
+            nfs_path=self.nfs_path,
+            host=self.host,
+            port=self.port,
+            rank_list=self.rank_list,
+            tls_path=self.tls_path
+        )
+
+    def get_run_ut_config(self, **config_params):
+        return RunUtConfig(
+            forward_content=config_params.get('forward_content'),
+            backward_content=config_params.get('backward_content'),
+            result_csv_path=config_params.get('result_csv_path'),
+            details_csv_path=config_params.get('details_csv_path'),
+            save_error_data=config_params.get('save_error_data'),
+            is_continue_run_ut=config_params.get('is_continue_run_ut'),
+            real_data_path=config_params.get('real_data_path'),
+            white_list=self.white_list,
+            black_list=self.black_list,
+            error_data_path=config_params.get('error_data_path'),
+            online_config=self.get_online_config()
+        )

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, ""