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

msprobe/mindspore/common/utils.py

@@ -1,4 +1,4 @@
-# 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");
@@ -20,6 +20,7 @@ import mindspore as ms
 
 from mindspore import ops
 from mindspore.mint import nn
+
 from msprobe.core.common.exceptions import DistributedNotInitializedError
 from msprobe.core.common.file_utils import path_len_exceeds_limit, check_path_exists, save_npy
 from msprobe.core.common.log import logger
@@ -43,7 +44,7 @@ def convert_bf16_to_fp32(tensor):
 def save_tensor_as_npy(tensor, file_path):
     if not path_len_exceeds_limit(file_path):
         tensor = convert_bf16_to_fp32(tensor)
-        saved_tensor = tensor.contiguous().asnumpy()
+        saved_tensor = tensor.asnumpy()
         save_npy(saved_tensor, file_path)
     else:
         logger.warning(f'The file path {file_path} length exceeds limit.')
@@ -56,6 +57,11 @@ def convert_to_int(value):
         return -1
 
 
+def clean_input_kwargs(cell):
+    if hasattr(cell, 'input_kwargs'):
+        del cell.input_kwargs
+
+
 def list_lowest_level_directories(root_dir):
     check_path_exists(root_dir)
     lowest_level_dirs = []
@@ -77,7 +83,7 @@ def list_lowest_level_directories(root_dir):
 
 
 def seed_all(seed=1234, mode=False, rm_dropout=True):
-    check_seed_all(seed, mode)
+    check_seed_all(seed, mode, rm_dropout)
     os.environ['PYTHONHASHSEED'] = str(seed)
     ms.set_seed(seed)
     random.seed(seed)
@@ -102,8 +108,8 @@ class MsprobeStep(ms.train.Callback):
 
 
 class Dropout(ops.Dropout):
-    def __init__(self, keep_prob=0.5, Seed0=0, Seed1=1):
-        super().__init__(1., Seed0, Seed1)
+    def __init__(self, keep_prob=0.5, seed0=0, seed1=1):
+        super().__init__(1., seed0, seed1)
 
 
 class Dropout2D(ops.Dropout2D):
@@ -134,3 +140,42 @@ def remove_dropout():
     ops.operations.Dropout3D = Dropout3D
     nn.Dropout = DropoutExt
     nn.functional.dropout = dropout_ext
+
+
+mindtorch_check_result = None
+
+
+def is_mindtorch():
+    global mindtorch_check_result
+    if mindtorch_check_result is None:
+        mindtorch_check_result = False
+        try:
+            import torch
+            from mindspore._c_expression import Tensor
+        except ImportError:
+            return mindtorch_check_result
+        tensor = torch.tensor(0.0)
+        if isinstance(tensor, Tensor):
+            mindtorch_check_result = True
+    return mindtorch_check_result
+
+
+register_backward_hook_functions = {}
+
+
+def set_register_backward_hook_functions():
+    global register_backward_hook_functions
+    if is_mindtorch():
+        import torch
+        from msprobe.mindspore.mindtorch import (_call_impl,
+                                                 register_full_backward_pre_hook,
+                                                 register_full_backward_hook)
+        if not hasattr(torch, "register_full_backward_hook"):
+            setattr(torch.nn.Module, "_call_impl", _call_impl)
+            setattr(torch.nn.Module, "register_full_backward_pre_hook", register_full_backward_pre_hook)
+            setattr(torch.nn.Module, "register_full_backward_hook", register_full_backward_hook)
+        register_backward_hook_functions["pre"] = torch.nn.Module.register_full_backward_pre_hook
+        register_backward_hook_functions["full"] = torch.nn.Module.register_full_backward_hook
+    else:
+        register_backward_hook_functions["pre"] = ms.nn.Cell.register_backward_pre_hook
+        register_backward_hook_functions["full"] = ms.nn.Cell.register_backward_hook

msprobe/mindspore/compare/distributed_compare.py

@@ -41,12 +41,10 @@ def ms_compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
         bench_data_dir = os.path.join(bench_dump_dir, br)
         npu_path = extract_json(npu_data_dir, stack_json=False)
         bench_path = extract_json(bench_data_dir, stack_json=False)
-        stack_path = extract_json(npu_data_dir, stack_json=True)
 
         dump_result_param = {
             'npu_json_path': npu_path,
             'bench_json_path': bench_path,
-            'stack_json_path': stack_path,
             'is_print_compare_log': is_print_compare_log
         }
         ms_compare(input_param=dump_result_param, output_path=output_path, suffix=f'_{nr}-{br}', **kwargs)

msprobe/mindspore/compare/ms_compare.py

@@ -1,4 +1,4 @@
-# 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,7 +15,6 @@
 
 import os
 import re
-
 from collections import defaultdict
 
 import numpy as np
@@ -23,15 +22,21 @@ import pandas as pd
 
 from msprobe.core.common.const import CompareConst, Const
 from msprobe.core.common.exceptions import FileCheckException
-from msprobe.core.common.file_utils import (FileOpen, create_directory, load_json,
-                                            load_npy, load_yaml)
+from msprobe.core.common.file_utils import FileOpen, create_directory, load_json, load_npy, load_yaml
 from msprobe.core.common.log import logger
-from msprobe.core.common.utils import (CompareException, check_compare_param,
-                                       check_configuration_param,
-                                       get_dump_mode, set_dump_path, check_op_str_pattern_valid)
+from msprobe.core.common.utils import CompareException, check_compare_param, check_configuration_param, \
+    check_op_str_pattern_valid, get_dump_mode, set_dump_path
+from msprobe.core.compare.acc_compare import Comparator, ModeConfig
 from msprobe.core.compare.check import dtype_mapping
-from msprobe.core.compare.acc_compare import Comparator
 from msprobe.core.compare.layer_mapping import generate_data_mapping_by_layer_mapping
+from msprobe.core.compare.utils import set_stack_json_path, reorder_op_x_list
+
+
+class MappingConfig:
+    def __init__(self, cell_mapping=None, api_mapping=None, data_mapping=None):
+        self.cell_mapping = cell_mapping
+        self.api_mapping = api_mapping
+        self.data_mapping = data_mapping
 
 
 class MSComparator(Comparator):
@@ -42,18 +47,27 @@ class MSComparator(Comparator):
     data_mapping: mindspore的cell或api的入参/出参和pytorch之间的映射关系；
     is_cross_framework: 是否跨框架。
     """
-    def __init__(self, cell_mapping=None, api_mapping=None, data_mapping=None, is_cross_framework=False):
+    def __init__(self, mode_config, mapping_config=None, is_cross_framework=False):
+        super().__init__(mode_config)
         self.frame_name = MSComparator.__name__
-        self.cell_mapping = cell_mapping
-        self.api_mapping = api_mapping
-        self.data_mapping = data_mapping
-        if data_mapping:
+
+        self.stack_mode = mode_config.stack_mode
+        self.auto_analyze = mode_config.auto_analyze
+        self.fuzzy_match = mode_config.fuzzy_match
+        self.dump_mode = mode_config.dump_mode
+
+        if mapping_config:
+            self.cell_mapping = mapping_config.cell_mapping
+            self.api_mapping = mapping_config.api_mapping
+            self.data_mapping = mapping_config.data_mapping
+
+        if self.data_mapping:
             self.cross_frame = is_cross_framework
         else:
-            self.cross_frame = cell_mapping is not None or api_mapping is not None
+            self.cross_frame = self.cell_mapping is not None or self.api_mapping is not None
         self.cell_mapping_dict = self.load_mapping_file(self.cell_mapping)
         self.api_mapping_dict = self.load_mapping_file(self.api_mapping)
-        if api_mapping is not None:
+        if self.api_mapping is not None:
             self.ms_to_pt_mapping = self.load_internal_api()
 
         if isinstance(self.data_mapping, str) or self.data_mapping is None:
@@ -63,9 +77,8 @@ class MSComparator(Comparator):
         else:
             raise TypeError(f"The type of parameter `data_mapping` must be dict, str or None, but got "
                             f"{type(self.data_mapping)}")
-    
-    @classmethod
-    def calc_accuracy(cls, result_df, dump_mode, header):
+
+    def calc_accuracy(self, result_df, header):
         condition_no_bench = result_df[CompareConst.BENCH_NAME] == CompareConst.N_A
         result_df[condition_no_bench] = result_df[condition_no_bench].fillna(CompareConst.N_A)
         result_df.loc[condition_no_bench, CompareConst.ERROR_MESSAGE] = CompareConst.NO_BENCH
@@ -76,10 +89,10 @@ class MSComparator(Comparator):
                 val_str = val.astype(str)
                 check_series[pd.to_numeric(val_str, errors='coerce').notna() | val_str.str.lower().eq('nan')] = True
                 return check_series
-            
+
             def get_number(val):
                 return pd.to_numeric(val.astype(str), errors='coerce')
-            
+
             ms_val = result_df['NPU ' + data_type]
             pt_val = result_df['Bench ' + data_type]
             diff_name = data_type.capitalize() + ' diff'
@@ -93,7 +106,7 @@ class MSComparator(Comparator):
             condition_pt_zero = pt_val == 0
             result_df.loc[condition_not_nan_diff & condition_pt_zero, rel_err_name] = CompareConst.NAN
             condition_ref_err = condition_not_nan_diff & ~condition_pt_zero
-            result_df.loc[condition_ref_err, rel_err_name] = (result_df.loc[condition_ref_err, diff_name] / 
+            result_df.loc[condition_ref_err, rel_err_name] = (result_df.loc[condition_ref_err, diff_name] /
                                                               pt_val[condition_ref_err] * 100)
             result_df.loc[condition_ref_err, rel_err_name] = (result_df.loc[condition_ref_err, rel_err_name]
                                                               .abs().astype(str) + '%')
@@ -101,31 +114,30 @@ class MSComparator(Comparator):
                     pd.Series(np.maximum(get_number(ms_val), get_number(pt_val))).abs() + CompareConst.EPSILON)
             return magnitude > CompareConst.MAGNITUDE
 
-        if dump_mode == Const.MD5:
+        if self.dump_mode == Const.MD5:
             condition_md5_equal = result_df[CompareConst.NPU_MD5] == result_df[CompareConst.BENCH_MD5]
             result_df.loc[condition_md5_equal, CompareConst.RESULT] = CompareConst.PASS
             result_df.loc[~condition_md5_equal & ~condition_no_bench, CompareConst.RESULT] = CompareConst.DIFF
-        elif dump_mode == Const.SUMMARY:
+        elif self.dump_mode == Const.SUMMARY:
             warning_list = [calc_summary_diff(data_type) for data_type in ['max', 'min', 'mean', 'l2norm']]
             warning_flag = pd.DataFrame(warning_list).all()
             result_df.loc[~condition_no_bench, [CompareConst.RESULT, CompareConst.ERROR_MESSAGE]] = ''
             result_df.loc[warning_flag, CompareConst.RESULT] = CompareConst.WARNING
             result_df.loc[warning_flag, CompareConst.ERROR_MESSAGE] = 'Need double check api accuracy.'
         else:
-            fill_cols = [CompareConst.COSINE, CompareConst.MAX_ABS_ERR, CompareConst.MAX_RELATIVE_ERR, 
+            fill_cols = [CompareConst.COSINE, CompareConst.MAX_ABS_ERR, CompareConst.MAX_RELATIVE_ERR,
                          CompareConst.ONE_THOUSANDTH_ERR_RATIO, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO,
                          CompareConst.ERROR_MESSAGE]
             result_df.loc[~condition_no_bench, fill_cols] = ''
             result_df.loc[~condition_no_bench, CompareConst.ACCURACY] = CompareConst.ACCURACY_CHECK_YES
         return result_df[header]
 
-    @classmethod
-    def make_result_df(cls, result, stack_mode, dump_mode):
-        header = CompareConst.HEAD_OF_COMPARE_MODE[dump_mode]
+    def make_result_df(self, result):
+        header = CompareConst.HEAD_OF_COMPARE_MODE[self.dump_mode][:]
 
-        if stack_mode:
+        if self.stack_mode:
             header.append(CompareConst.STACK)
-        if dump_mode == Const.ALL:
+        if self.dump_mode == Const.ALL:
             header.append(CompareConst.DATA_NAME)
         result.rename(columns={'op_name_x': CompareConst.NPU_NAME,
                                'op_name_y': CompareConst.BENCH_NAME,
@@ -137,10 +149,11 @@ class MSComparator(Comparator):
                                'md5_y': CompareConst.BENCH_MD5,
                                'data_name_x': CompareConst.DATA_NAME,
                                'stack_info_x': CompareConst.STACK}, inplace=True)
-        
+
         npu_summary = [CompareConst.NPU_MAX, CompareConst.NPU_MIN, CompareConst.NPU_MEAN, CompareConst.NPU_NORM]
-        bench_summary = [CompareConst.BENCH_MAX, CompareConst.BENCH_MIN, CompareConst.BENCH_MEAN, 
+        bench_summary = [CompareConst.BENCH_MAX, CompareConst.BENCH_MIN, CompareConst.BENCH_MEAN,
                          CompareConst.BENCH_NORM]
+
         def set_summary(summary):
             if summary == CompareConst.N_A:
                 return [CompareConst.N_A] * 4
@@ -153,14 +166,14 @@ class MSComparator(Comparator):
                 else:
                     summary_list.append(i)
             return summary_list
-        
+
         result[npu_summary] = result['summary_x'].apply(set_summary).tolist()
         result[bench_summary] = result['summary_y'].apply(set_summary).tolist()
         result_df = pd.DataFrame(columns=header)
         for h in header:
             if h in result.columns:
                 result_df[h] = result[h]
-        return cls.calc_accuracy(result_df, dump_mode, header)
+        return self.calc_accuracy(result_df, header)
 
     def load_internal_api(self):
         cur_path = os.path.dirname(os.path.realpath(__file__))
@@ -175,13 +188,16 @@ class MSComparator(Comparator):
         return mapping_dict
 
     def process_cell_mapping(self, npu_op_name):
-        if not npu_op_name or not re.match(r'.+(?:for|back)ward\..+', npu_op_name):
+        if not npu_op_name:
+            return CompareConst.N_A
+        param_grad_flag = Const.PARAMS_GRAD in npu_op_name.split(Const.SEP)
+        if not param_grad_flag and not re.search(Const.REGEX_FORWARD_BACKWARD, npu_op_name):
             return CompareConst.N_A
         npu_op_name = npu_op_name.replace("Cell", "Module", 1)
         if self.cell_mapping_dict:
             # get cell name & class name from op_name
             # Cell.fc1.Dense.forward.0.input.0
-            cell_name = re.split(r'\.(?:for|back)ward\.', npu_op_name.split(Const.SEP, 1)[-1])[0]
+            cell_name = re.split(r'\.(?:forward|backward|parameters_grad)\.', npu_op_name.split(Const.SEP, 1)[-1])[0]
             if cell_name in self.cell_mapping_dict:
                 npu_op_name = npu_op_name.replace(cell_name, self.cell_mapping_dict[cell_name], 1)
         return npu_op_name
@@ -198,7 +214,7 @@ class MSComparator(Comparator):
                 data_value = data_value.to(torch.float32)
             data_value = data_value.numpy()
         else:
-            data_value = load_npy(data_path) 
+            data_value = load_npy(data_path)
         return data_value
 
     def process_internal_api_mapping(self, npu_op_name):
@@ -214,7 +230,7 @@ class MSComparator(Comparator):
             return npu_op_name.replace(ms_api_name, self.ms_to_pt_mapping.get(ms_api_name))
         else:
             return npu_op_name
-    
+
     def get_api_name(self, api_list):
         try:
             api_name = api_list[0] + Const.SEP + api_list[1]
@@ -223,14 +239,14 @@ class MSComparator(Comparator):
             raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from error
         return api_name
 
-    def compare_process(self, file_lists, stack_mode, fuzzy_match, dump_mode):
+    def compare_process(self, file_lists):
         npu_json_path, bench_json_path, stack_json_path = file_lists
         npu_json_data = load_json(npu_json_path)
         bench_json_data = load_json(bench_json_path)
-        stack_json_data = load_json(stack_json_path)
+        stack_json_data = load_json(stack_json_path) if self.stack_mode else None
 
-        npu_df = self.gen_data_df(npu_json_data, stack_json_data, dump_mode)
-        bench_df = self.gen_data_df(bench_json_data, stack_json_data, dump_mode)
+        npu_df = self.gen_data_df(npu_json_data, stack_json_data)
+        bench_df = self.gen_data_df(bench_json_data, stack_json_data)
         if self.cell_mapping:
             npu_df[CompareConst.COMPARE_KEY] = npu_df[CompareConst.OP_NAME].apply(self.process_cell_mapping)
         elif self.api_mapping:
@@ -242,8 +258,8 @@ class MSComparator(Comparator):
         npu_df[[Const.DTYPE, Const.SHAPE]] = npu_df[[Const.DTYPE, Const.SHAPE]].astype(str)
         bench_df[[Const.DTYPE, Const.SHAPE]] = bench_df[[Const.DTYPE, Const.SHAPE]].astype(str)
         npu_df[CompareConst.COMPARE_SHAPE] = npu_df[Const.SHAPE]
-        bench_df[CompareConst.COMPARE_SHAPE] = bench_df[Const.SHAPE]
         bench_df[CompareConst.COMPARE_KEY] = bench_df[CompareConst.OP_NAME]
+        bench_df[CompareConst.COMPARE_SHAPE] = bench_df[Const.SHAPE]
         match_result = pd.merge(npu_df, bench_df, on=[CompareConst.COMPARE_KEY, CompareConst.COMPARE_SHAPE],
                                 how='outer')
         match_result = match_result[match_result['op_name_x'].notna()].fillna(CompareConst.N_A)
@@ -262,9 +278,9 @@ class MSComparator(Comparator):
                     ((npu_dtype == Const.TORCH_FLOAT32) & (bench_dtype == Const.TORCH_FLOAT16)) |
                     ((npu_dtype == Const.TORCH_FLOAT16) & (bench_dtype == Const.TORCH_BFLOAT16)) |
                     ((npu_dtype == Const.TORCH_BFLOAT16) & (bench_dtype == Const.TORCH_FLOAT16)))
-        
+
         match_result.loc[~gen_dtype_condition(), [i + '_y' for i in bench_df.columns]] = CompareConst.N_A
-        return MSComparator.make_result_df(match_result, stack_mode, dump_mode)
+        return self.make_result_df(match_result)
 
     def modify_compare_data_with_user_mapping(self, npu_df, bench_df):
         def get_api_indices_dict(op_name_df):
@@ -288,11 +304,17 @@ class MSComparator(Comparator):
             return flag
 
         for mapping_dict in self.api_mapping_dict:
-            if (len(mapping_dict.get('ms_args')) != len(mapping_dict.get('pt_args')) or
-                    len(mapping_dict.get('ms_output')) != len(mapping_dict.get('pt_output'))):
+            keys_to_compare = [
+                ('ms_args', 'pt_args'),
+                ('ms_output', 'pt_output'),
+                ('ms_parameters', 'pt_parameters'),
+                ('ms_parameters_grad', 'pt_parameters_grad'),
+            ]
+            if not all(len(mapping_dict.get(k1, [])) == len(mapping_dict.get(k2, [])) for k1, k2 in keys_to_compare):
                 logger.warning('The user-defined mapping table is incorrect,\
                                 make sure that the number of parameters is equal')
                 continue
+
             ms_api, pt_api = mapping_dict.get('ms_api'), mapping_dict.get('pt_api')
             if ms_api not in ms_api_indices_dict or pt_api not in pt_api_indices_dict:
                 continue
@@ -304,13 +326,17 @@ class MSComparator(Comparator):
                     is_abandoned = gen_input_compare_key(CompareConst.KWARGS_PATTERN, 'args')
                 elif CompareConst.OUTPUT_PATTERN in op_name:
                     is_abandoned = gen_input_compare_key(CompareConst.OUTPUT_PATTERN, 'output')
+                elif CompareConst.PARAMS_PATTERN in op_name:
+                    is_abandoned = gen_input_compare_key(CompareConst.PARAMS_PATTERN, 'parameters')
+                elif CompareConst.PARAMS_GRAD_PATTERN in op_name:
+                    is_abandoned = gen_input_compare_key(CompareConst.PARAMS_GRAD_PATTERN, 'parameters_grad')
                 else:
                     logger.error(f'Excepted op_name: {op_name}')
                     raise CompareException(CompareException.INVALID_DATA_ERROR)
                 if is_abandoned:
                     npu_df.loc[index, CompareConst.COMPARE_KEY] = op_name + 'abandoned'
 
-    def gen_data_df(self, data_json, stack_json, dump_mode):
+    def gen_data_df(self, data_json, stack_json_data):
         result = {
             CompareConst.OP_NAME: [],
             Const.DTYPE: [],
@@ -318,29 +344,40 @@ class MSComparator(Comparator):
             Const.SUMMARY: [],
             'stack_info': []
         }
-        if dump_mode == Const.ALL:
+        if self.dump_mode == Const.ALL:
             result['data_name'] = []
-        elif dump_mode == Const.MD5:
+        elif self.dump_mode == Const.MD5:
             result[Const.MD5] = []
         for data_name in data_json['data']:
             check_op_str_pattern_valid(data_name)
-            merge_list = self.gen_merge_list(data_json, data_name, stack_json, dump_mode)
+            merge_list = self.gen_merge_list(data_json, data_name, stack_json_data)
             if not merge_list:
                 continue
-            for op_name in merge_list[CompareConst.OP_NAME]:
+
+            op_name_list = merge_list.get(CompareConst.OP_NAME)
+            summary_list = merge_list.get(Const.SUMMARY)
+            data_name_list = merge_list.get('data_name')
+            op_name_reorder, summary_reorder, data_name_reorder = reorder_op_x_list(op_name_list,
+                                                                                    summary_list,
+                                                                                    data_name_list)
+            for op_name in op_name_reorder:
                 result[CompareConst.OP_NAME].append(op_name)
                 if (CompareConst.INPUT_PATTERN in op_name) or (CompareConst.KWARGS_PATTERN in op_name):
                     struct = merge_list[CompareConst.INPUT_STRUCT].pop(0)
-                else:
+                elif CompareConst.OUTPUT_PATTERN in op_name:
                     struct = merge_list[CompareConst.OUTPUT_STRUCT].pop(0)
+                elif CompareConst.PARAMS_PATTERN in op_name:
+                    struct = merge_list[CompareConst.PARAMS_STRUCT].pop(0)
+                else:
+                    struct = merge_list[CompareConst.PARAMS_GRAD_STRUCT].pop(0)
                 result[Const.DTYPE].append(struct[0])
                 result[Const.SHAPE].append(struct[1])
-                if dump_mode == Const.MD5:
+                if self.dump_mode == Const.MD5:
                     result[Const.MD5].append(struct[2])
-                result[Const.SUMMARY].append(merge_list[Const.SUMMARY].pop(0))
-                result['stack_info'].append(merge_list['stack_info'][0])
-                if dump_mode == Const.ALL:
-                    result['data_name'].append(merge_list['data_name'].pop(0))
+                result[Const.SUMMARY].append(summary_reorder.pop(0))
+                result['stack_info'].append(merge_list['stack_info'][0] if self.stack_mode else None)
+                if self.dump_mode == Const.ALL:
+                    result['data_name'].append(data_name_reorder.pop(0))
         return pd.DataFrame(result)
 
 
@@ -355,7 +392,6 @@ def check_cross_framework(bench_json_path):
 
 def ms_compare(input_param, output_path, **kwargs):
     try:
-        stack_mode = kwargs.get('stack_mode', False)
         auto_analyze = kwargs.get('auto_analyze', True)
         fuzzy_match = kwargs.get('fuzzy_match', False)
         cell_mapping = kwargs.get('cell_mapping', None)
@@ -366,15 +402,21 @@ def ms_compare(input_param, output_path, **kwargs):
 
         set_dump_path(input_param)
         dump_mode = get_dump_mode(input_param)
+        if 'stack_json_path' in input_param:
+            stack_mode = kwargs.get('stack_mode', False)
+        else:
+            stack_mode = set_stack_json_path(input_param)  # set stack_mode and set "stack_json_path" in input_param
         check_configuration_param(stack_mode, auto_analyze, fuzzy_match, input_param.get('is_print_compare_log', True))
         create_directory(output_path)
-        check_compare_param(input_param, output_path, dump_mode)
+        check_compare_param(input_param, output_path, dump_mode, stack_mode)
     except (CompareException, FileCheckException) as error:
         logger.error('Compare failed. Please check the arguments and do it again!')
         raise CompareException(error.code) from error
     if layer_mapping:
         data_mapping = generate_data_mapping_by_layer_mapping(input_param, layer_mapping, output_path)
-    is_cross_framework = check_cross_framework(input_param.get("bench_json_path"))
-    ms_comparator = MSComparator(cell_mapping, api_mapping, data_mapping, is_cross_framework)
-    ms_comparator.compare_core(input_param, output_path, stack_mode=stack_mode, suffix=suffix,
-                 auto_analyze=auto_analyze, fuzzy_match=fuzzy_match, dump_mode=dump_mode)
+
+    mode_config = ModeConfig(stack_mode, auto_analyze, fuzzy_match, dump_mode)
+    mapping_config = MappingConfig(cell_mapping, api_mapping, data_mapping)
+    is_cross_framework = check_cross_framework(input_param.get('bench_json_path'))
+    ms_comparator = MSComparator(mode_config, mapping_config, is_cross_framework)
+    ms_comparator.compare_core(input_param, output_path, suffix=suffix)

msprobe/mindspore/compare/ms_graph_compare.py

@@ -25,7 +25,7 @@ from msprobe.core.common.file_utils import load_npy, read_csv, save_excel
 from msprobe.core.common.log import logger
 from msprobe.core.common.utils import add_time_with_xlsx, CompareException
 from msprobe.core.compare.multiprocessing_compute import _ms_graph_handle_multi_process, check_accuracy
-from msprobe.core.compare.npy_compare import npy_data_check, statistics_data_check, reshape_value, compare_ops_apply
+from msprobe.core.compare.npy_compare import npy_data_check, statistics_data_check, compare_ops_apply
 from msprobe.mindspore.common.utils import convert_to_int, list_lowest_level_directories
 
 
@@ -144,10 +144,16 @@ def generate_data_name(data_path):
         mode = GraphMode.STATISTIC_MODE
     else:
         mode = GraphMode.ERROR_MODE
-        logger.error(f"Error mode.")
+        logger.error("Error mode.")
     return mode, data_list
 
 
+def transform_special_string_into_float(data_frame):
+    data_frame[data_frame == "null"] = '0'
+    data_frame[data_frame == "False"] = '0'
+    data_frame[data_frame == "True"] = '1'
+
+
 class GraphMSComparator:
     def __init__(self, input_param, output_path):
         self.output_path = output_path
@@ -187,7 +193,6 @@ class GraphMSComparator:
             result_dict[CompareConst.ERROR_MESSAGE] = error_message
 
             if not error_flag:
-                n_value, b_value = reshape_value(n_value, b_value)
                 result_list, err_msg = compare_ops_apply(n_value, b_value, False, "")
                 result_dict[CompareConst.COSINE] = result_list[0]
                 result_dict[CompareConst.MAX_ABS_ERR] = result_list[1]
@@ -334,13 +339,17 @@ class GraphMSComparator:
                                                   CompareConst.BENCH_NORM])
 
             npu_float_type = [CompareConst.NPU_MAX, CompareConst.NPU_MIN, CompareConst.NPU_MEAN, CompareConst.NPU_NORM]
-            npu_data_df[npu_float_type] = npu_data_df[npu_float_type].astype(float)
+            npu_float_data_df = npu_data_df[npu_float_type].astype(str)
+            transform_special_string_into_float(npu_float_data_df)
+            npu_data_df[npu_float_type] = npu_float_data_df.astype(float)
 
             bench_float_type = [
                 CompareConst.BENCH_MAX, CompareConst.BENCH_MIN,
                 CompareConst.BENCH_MEAN, CompareConst.BENCH_NORM
             ]
-            bench_data_df[bench_float_type] = bench_data_df[bench_float_type].astype(float)
+            bench_float_data_df = bench_data_df[bench_float_type].astype(str)
+            transform_special_string_into_float(bench_float_data_df)
+            bench_data_df[bench_float_type] = bench_float_data_df.astype(float)
 
         npu_data_df['Local Index'] = npu_data_df.sort_values('TimeStamp').groupby('Compare Key').cumcount()
         bench_data_df['Local Index'] = bench_data_df.sort_values('TimeStamp').groupby('Compare Key').cumcount()

msprobe/mindspore/debugger/debugger_config.py

@@ -39,6 +39,7 @@ class DebuggerConfig:
         self.check_mode = task_config.check_mode
         self.framework = Const.MS_FRAMEWORK
         self.summary_mode = task_config.summary_mode
+        self.async_dump = common_config.async_dump if common_config.async_dump else False
         self.check()
         create_directory(self.dump_path)
 
@@ -69,4 +70,6 @@ class DebuggerConfig:
             self.file_format = "npy"
         if not self.check_mode:
             self.check_mode = "all"
+        if not isinstance(self.async_dump, bool):
+            raise Exception("The parameters async_dump should be bool.")
         return True