mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/core/compare/torchair_cmp_utils.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Utility helpers that support the torchair accuracy comparison flow.
+"""
+
+import datetime
+import os
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from msprobe.core.common.const import FileCheckConst
+from msprobe.core.common.file_utils import FileChecker, create_directory, write_df_to_csv
+from msprobe.core.common.log import logger
+from msprobe.infer.utils.check.rule import Rule
+from msprobe.infer.utils.constants import TENSOR_MAX_SIZE
+from msprobe.infer.utils.util import safe_torch_load
+
+GLOBAL_HISTORY_AIT_DUMP_PATH_LIST = ["msit_dump", "ait_dump"]
+
+TOKEN_ID = "token_id"
+DATA_ID = "data_id"
+GOLDEN_DATA_PATH = "golden_data_path"
+GOLDEN_DTYPE = "golden_dtype"
+GOLDEN_SHAPE = "golden_shape"
+GOLDEN_MAX_VALUE = "golden_max_value"
+GOLDEN_MIN_VALUE = "golden_min_value"
+GOLDEN_MEAN_VALUE = "golden_mean_value"
+GOLDEN_OP_TYPE = "golden_op_type"
+MY_DATA_PATH = "my_data_path"
+MY_DTYPE = "my_dtype"
+MY_SHAPE = "my_shape"
+MY_MAX_VALUE = "my_max_value"
+MY_MIN_VALUE = "my_min_value"
+MY_MEAN_VALUE = "my_mean_value"
+MY_OP_TYPE = "my_op_type"
+CMP_FAIL_REASON = "cmp_fail_reason"
+DTYPE = "dtype"
+SHAPE = "shape"
+MAX_VALUE = "max_value"
+MIN_VALUE = "min_value"
+MEAN_VALUE = "mean_value"
+
+CSV_GOLDEN_HEADER_BASE = [
+    TOKEN_ID,
+    DATA_ID,
+    GOLDEN_DATA_PATH,
+    GOLDEN_OP_TYPE,
+    GOLDEN_DTYPE,
+    GOLDEN_SHAPE,
+    GOLDEN_MAX_VALUE,
+    GOLDEN_MIN_VALUE,
+    GOLDEN_MEAN_VALUE,
+    MY_DATA_PATH,
+    MY_OP_TYPE,
+    MY_DTYPE,
+    MY_SHAPE,
+    MY_MAX_VALUE,
+    MY_MIN_VALUE,
+    MY_MEAN_VALUE,
+]
+
+
+def _lazy_import_torch():
+    try:
+        import torch  # pylint: disable=import-outside-toplevel
+    except ModuleNotFoundError as err:
+        if err.name == "torch":
+            logger.error("Missing dependency: torch. Please install torch to use torchair compare.")
+        raise
+    return torch
+
+
+def _lazy_cmp_alg_maps():
+    from msprobe.infer.utils import cmp_algorithm  # pylint: disable=import-outside-toplevel
+
+    return cmp_algorithm.CMP_ALG_MAP, cmp_algorithm.CUSTOM_ALG_MAP
+
+
+def _build_csv_golden_header():
+    cmp_alg_map, _ = _lazy_cmp_alg_maps()
+    header = list(CSV_GOLDEN_HEADER_BASE)
+    header.extend(list(cmp_alg_map.keys()))
+    header.append(CMP_FAIL_REASON)
+    return header
+
+
+class BasicDataInfo:
+    """Metadata holder for a pair of tensors."""
+
+    count_data_id = 0  # Count data_id, increment by 1 every time creating a new instance
+    TORCH_UNSUPPORTED_D_TYPE_MAP = {"uint16": "int32", "uint32": "int64"}
+
+    def __init__(self, golden_data_path, my_data_path, token_id=None, data_id=None, op_type=None):
+        global_path = os.path.realpath(golden_data_path.split(",")[0])
+        self._check_path(global_path)
+        my_real_path = os.path.realpath(my_data_path.split(",")[0])
+        self._check_path(my_real_path)
+
+        self.my_data_path, self.golden_data_path = os.path.realpath(my_data_path), os.path.realpath(golden_data_path)
+        self.token_id = self.get_token_id(self.my_data_path) if token_id is None else token_id
+        self.data_id = self.count_data_id if data_id is None else data_id
+        self.my_op_type, self.golden_op_type = self._validate_op_type(op_type)
+        self._count()
+
+    @staticmethod
+    def _check_path(path):
+        path_type = FileCheckConst.DIR if os.path.isdir(path) else FileCheckConst.FILE
+        FileChecker(path, path_type, ability=FileCheckConst.READ_ABLE).common_check()
+
+    @staticmethod
+    def _validate_op_type(op_type):
+        if op_type is None:
+            return None, None
+
+        if isinstance(op_type, (list, tuple)) and len(op_type) == 2:
+            return op_type[0], op_type[1]
+        raise ValueError("op_type must be a list or tuple containing two elements")
+
+    @classmethod
+    def _count(cls):
+        cls.count_data_id += 1
+
+    def to_dict(self):
+        return {
+            TOKEN_ID: str(self.token_id),
+            DATA_ID: str(self.data_id),
+            GOLDEN_DATA_PATH: self.golden_data_path,
+            GOLDEN_OP_TYPE: self.golden_op_type,
+            MY_DATA_PATH: self.my_data_path,
+            MY_OP_TYPE: self.my_op_type,
+        }
+
+    def get_token_id(self, cur_path):
+        dump_filename_idx = 4
+        dump_tensor_idx = 3
+        dirseg = cur_path.split(os.path.sep)
+        if len(dirseg) > 16:
+            raise RecursionError(f'The depth of "{cur_path}" directory is too deep.')
+        if len(dirseg) < dump_filename_idx:
+            return 0
+        flag1 = dirseg[-dump_tensor_idx] in {"tensors", "torch_tensors"}
+        flag2 = any(dirseg[-dump_filename_idx].startswith(x) for x in GLOBAL_HISTORY_AIT_DUMP_PATH_LIST)
+        if flag1 and flag2:
+            try:
+                token_id = int(dirseg[-1])
+            except (IndexError, AttributeError, TypeError, ValueError) as err:
+                logger.debug(f"get_token_id error, dirseg: {dirseg}, error: {err}")
+                token_id = 0
+        else:
+            token_id = self.get_token_id(os.path.dirname(cur_path))
+        return token_id
+
+
+def fill_row_data(
+    data_info: BasicDataInfo,
+    loaded_my_data: Any = None,
+    loaded_golden_data: Any = None,
+):
+    golden_data_path, my_data_path = data_info.golden_data_path, data_info.my_data_path
+    row_data = data_info.to_dict()
+    if loaded_golden_data is None and not os.path.isfile(golden_data_path):
+        row_data[CMP_FAIL_REASON] = f"golden_data_path: {golden_data_path} is not a file."
+        return row_data
+    if loaded_my_data is None and not os.path.isfile(my_data_path):
+        row_data[CMP_FAIL_REASON] = f"my_data_path: {my_data_path} is not a file."
+        return row_data
+    golden_data = load_as_torch_tensor(golden_data_path, loaded_golden_data)
+    my_data = load_as_torch_tensor(my_data_path, loaded_my_data)
+
+    compare_metrics_dict = compare_data(golden_data, my_data)
+    tensor_basic_info_dict = set_tensor_basic_info_in_row_data(golden_data, my_data)
+    row_data.update(compare_metrics_dict)
+    row_data.update(tensor_basic_info_dict)
+
+    return row_data
+
+
+def load_as_torch_tensor(data_path, loaded_data=None):
+    torch = _lazy_import_torch()
+    if loaded_data is not None:
+        if str(loaded_data.dtype) in BasicDataInfo.TORCH_UNSUPPORTED_D_TYPE_MAP:
+            mapped = BasicDataInfo.TORCH_UNSUPPORTED_D_TYPE_MAP.get(str(loaded_data.dtype))
+            loaded_data = loaded_data.astype(mapped)
+        return loaded_data if isinstance(loaded_data, torch.Tensor) else torch.from_numpy(loaded_data)
+    return read_data(data_path)
+
+
+def get_tensor_basic_info(data: Any) -> Dict[str, Any]:
+    tensor_info: Dict[str, Any] = {}
+    tensor_info[DTYPE] = str(data.dtype)
+    tensor_info[SHAPE] = str(list(data.shape))
+    if 0 not in data.shape:
+        data = data.float()
+        tensor_info[MAX_VALUE] = data.max().item()
+        tensor_info[MIN_VALUE] = data.min().item()
+        tensor_info[MEAN_VALUE] = data.mean().item()
+    return tensor_info
+
+
+def set_tensor_basic_info_in_row_data(golden_data, my_data):
+    row_data: Dict[str, Any] = {}
+    golden_info = get_tensor_basic_info(golden_data)
+    row_data.update({f"golden_{key}": value for key, value in golden_info.items()})
+
+    my_info = get_tensor_basic_info(my_data)
+    row_data.update({f"my_{key}": value for key, value in my_info.items()})
+    return row_data
+
+
+def save_compare_result_to_csv(gathered_row_data, output_path=".", columns=None, rank_id=-1):
+    create_directory(output_path)
+    cur_time = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d%H%M%S")
+    columns = columns or _build_csv_golden_header()
+    if rank_id != -1:
+        csv_save_path = os.path.join(output_path, f"msit_cmp_report_rank{rank_id}_{cur_time}.csv")
+    else:
+        csv_save_path = os.path.join(output_path, f"msit_cmp_report_{cur_time}.csv")
+    gathered_row_data = list(
+        filter(
+            lambda item: not (CMP_FAIL_REASON in item and item[CMP_FAIL_REASON] == "data shape doesn't match."),
+            gathered_row_data,
+        )
+    )
+    for row_data in gathered_row_data[:]:
+        if GOLDEN_DTYPE in row_data and MY_DTYPE in row_data:
+            if (row_data[GOLDEN_DTYPE] == "torch.int8") ^ (row_data[MY_DTYPE] == "torch.int8"):
+                gathered_row_data.remove(row_data)
+
+    data_frame = pd.DataFrame(gathered_row_data, columns=columns)
+    data_frame.fillna(value="", inplace=True)
+    data_frame.dropna(axis=0, how="all", inplace=True)
+    write_df_to_csv(data_frame, csv_save_path)
+    logger.info(f"Saved comparing results: {csv_save_path}")
+    return csv_save_path
+
+
+def compare_data(golden_data, my_data):
+    torch = _lazy_import_torch()
+    if not hasattr(compare_data, "index"):
+        compare_data.index = 0
+
+    golden_data_dtype = golden_data.dtype
+    my_data_dtype = my_data.dtype
+    if golden_data_dtype != torch.float32:
+        logger.debug(
+            f"The dtype of golden_data with index {compare_data.index} is {golden_data_dtype}, convert it to fp32"
+        )
+    if my_data_dtype != torch.float32:
+        logger.debug(f"The dtype of my_data with index {compare_data.index} is {my_data_dtype}, convert it to fp32")
+    golden_data_fp32 = golden_data.reshape(-1).float()
+    my_data_fp32 = my_data.reshape(-1).float()
+    compare_data.index += 1
+    compare_metrics_dict = compare_tensor(golden_data_fp32, my_data_fp32)
+    return compare_metrics_dict
+
+
+def read_data(data_path):
+    torch = _lazy_import_torch()
+    data_path = os.path.realpath(data_path)
+    Rule.input_file().check(data_path, will_raise=True)
+    if data_path.endswith(".npy"):
+        data = torch.as_tensor(np.load(data_path, allow_pickle=False))
+    elif data_path.endswith((".pth", ".pt")):
+        data = safe_torch_load(data_path, map_location=torch.device("cpu"))
+    else:
+        logger.error(f"Unsupported data format {data_path}")
+        raise TypeError("Unsupported data format.")
+
+    if isinstance(data, torch.Tensor):
+        return data.cpu()
+    if isinstance(data, np.ndarray):
+        return torch.from_numpy(data)
+    if isinstance(data, (list, tuple)):
+        return torch.as_tensor(data)
+    logger.error(f"Unsupported tensor content type {type(data)} from {data_path}")
+    raise TypeError("Unsupported tensor content type.")
+
+
+def compare_tensor(golden_data_fp32, my_data_fp32):
+    row_data: Dict[str, Any] = {}
+    fail_messages: List[str] = []
+
+    tensor_pass, message = check_tensor(golden_data_fp32, my_data_fp32)
+    if not tensor_pass:
+        logger.debug(f"check_tensor failed: {message}")
+        row_data[CMP_FAIL_REASON] = message
+        return row_data
+
+    cmp_alg_map, custom_alg_map = _lazy_cmp_alg_maps()
+    for name, cmp_func in list(cmp_alg_map.items()) + list(custom_alg_map.items()):
+        result, message = cmp_func(golden_data_fp32, my_data_fp32)
+        row_data[name] = result
+        if message:
+            fail_messages.append(message)
+    row_data[CMP_FAIL_REASON] = " ".join(fail_messages)
+    return row_data
+
+
+def check_tensor(golden_data_fp32, my_data_fp32):
+    torch = _lazy_import_torch()
+    tensor_pass = True
+    fail_reasons = []
+
+    if len(golden_data_fp32) != len(my_data_fp32):
+        fail_reasons.append("data shape doesn't match.")
+        tensor_pass = False
+    if not torch.all(torch.isfinite(golden_data_fp32)):
+        fail_reasons.append("golden_data includes NAN or inf.")
+        tensor_pass = False
+    if not torch.all(torch.isfinite(my_data_fp32)):
+        fail_reasons.append("my_data includes NAN or inf.")
+        tensor_pass = False
+    return tensor_pass, " ".join(fail_reasons)
+
+
+__all__ = [
+    "BasicDataInfo",
+    "fill_row_data",
+    "save_compare_result_to_csv",
+]

msprobe/core/compare/utils.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import os
 import re
@@ -24,7 +25,8 @@ import numpy as np
 import pandas as pd
 
 from msprobe.core.common.const import Const, CompareConst, FileCheckConst
-from msprobe.core.common.utils import CompareException, check_regex_prefix_format_valid, logger, safe_get_value
+from msprobe.core.common.utils import CompareException, check_regex_prefix_format_valid, logger, \
+    safe_get_value, is_module_available
 from msprobe.core.common.file_utils import check_file_or_directory_path, load_json
 
 json_file_mapping = {
@@ -58,10 +60,10 @@ def extract_json(dirname, json_file_type):
 
 
 def set_stack_json_path(input_param):
-    npu_data_dir = os.path.dirname(input_param.get("npu_json_path"))
+    npu_data_dir = os.path.dirname(input_param.get("npu_path"))
     stack_path = extract_json(npu_data_dir, json_file_type=Const.STACK_JSON_FILE)
-    input_param["stack_json_path"] = stack_path if stack_path else None
-    return bool(stack_path)
+    input_param["stack_path"] = stack_path if stack_path else None
+    return bool(stack_path), input_param
 
 
 def check_and_return_dir_contents(dump_dir, prefix):
@@ -101,7 +103,8 @@ def read_op(op_data, op_name):
     split_name = op_name.split(Const.SEP)
     if split_name[-1] == Const.DEBUG:
         op_parsed_list = op_item_parse(op_data, op_name, Const.DEBUG)
-    elif split_name[-1] == Const.PARAMS_GRAD:
+    # 倒序校验parameters_grad，先倒数1，再倒数2，排除因为parameters_grad在模块名中而误判的风险。-1适配老版，-2适配新版。
+    elif split_name[-1] == Const.PARAMS_GRAD or (len(split_name) >= 2 and split_name[-2] == Const.PARAMS_GRAD):
         op_parsed_list = op_item_parse(op_data, op_name, Const.PARAMS_GRAD)
     else:
         op_parsed_list = []
@@ -571,15 +574,23 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
                             n_requires_grad, CompareConst.NAN,
                             n_struct[2], CompareConst.NAN,
                             False,
-                            CompareConst.NAN
+                            CompareConst.NAN,
+                            None
                         ]
                         result.append(result_item)
                         continue
-                    result_item = [
-                        n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, n_struct[1], CompareConst.NAN,
-                        n_requires_grad, CompareConst.NAN,
-                        " ", " ", " ", " ", " ", " "
-                    ]
+                    if dump_mode == Const.ALL:
+                        result_item = [
+                            n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, n_struct[1], CompareConst.NAN,
+                            n_requires_grad, CompareConst.NAN,
+                            " ", " ", " ", " ", " ", " "
+                        ]
+                    else:
+                        result_item = [
+                            n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, n_struct[1], CompareConst.NAN,
+                            n_requires_grad, CompareConst.NAN,
+                            " ", " ", " ", " ", " ", " ", " ", " "
+                        ]
                     summary_data = n_dict.get(CompareConst.SUMMARY)[n_start + index]
                     result_item.extend(summary_data)
                     summary_data = [CompareConst.NAN for _ in range(len(n_dict.get(CompareConst.SUMMARY)[0]))]
@@ -592,7 +603,7 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
                     raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from e
 
                 err_msg = ""
-                result_item.append(CompareConst.ACCURACY_CHECK_YES)
+                result_item.append(CompareConst.PASS)
                 result_item.append(err_msg)
                 result_item = stack_column_process(result_item, has_stack, index, key, npu_stack_info)
                 if dump_mode == Const.ALL:
@@ -605,11 +616,12 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
     _, b_num_input, b_num_output, b_num_params, b_num_params_grad = count_struct(b_dict)
 
     get_accuracy_core(0, n_num_input, 0, b_num_input, CompareConst.INPUT_STRUCT)
-    get_accuracy_core(n_num_input + n_num_output, n_num_params, b_num_input + b_num_output, b_num_params,
+    get_accuracy_core(n_num_input, n_num_params, b_num_input, b_num_params,
                       CompareConst.PARAMS_STRUCT)
-    get_accuracy_core(n_num_input, n_num_output, b_num_input, b_num_output, CompareConst.OUTPUT_STRUCT)
-    get_accuracy_core(n_num_input + n_num_output + n_num_params, n_num_params_grad,
-                      b_num_input + b_num_output + b_num_params, b_num_params_grad,
+    get_accuracy_core(n_num_input + n_num_params, n_num_output, b_num_input + b_num_params, b_num_output,
+                      CompareConst.OUTPUT_STRUCT)
+    get_accuracy_core(n_num_input + n_num_params + n_num_output, n_num_params_grad,
+                      b_num_input + b_num_params + b_num_output, b_num_params_grad,
                       CompareConst.PARAMS_GRAD_STRUCT)
 
 
@@ -650,19 +662,18 @@ def get_paired_dirs(npu_path, bench_path):
 
 
 def _compare_parser(parser):
-    parser.add_argument("-i", "--input_path", dest="input_path", type=str,
-                        help="<Required> The compare input path, a dict json.", required=True)
+    parser.add_argument("-m", "--mode", dest="mode", type=str, default="auto",
+                        help="<optional> Comparison mode: 'auto' (default) or 'torchair' for torchair accuracy compare",
+                        required=False)
+    parser.add_argument("-tp", "--target_path", dest="target_path", type=str,
+                        help="<Required> The compare target device path", required=True)
+    parser.add_argument("-gp", "--golden_path", dest="golden_path", type=str,
+                        help="<Required> The compare golden device path", required=True)
     parser.add_argument("-o", "--output_path", dest="output_path", type=str,
                         help="<Required> The compare task result out path. Default path: ./output",
                         required=False, default="./output", nargs="?", const="./output")
-    parser.add_argument("-s", "--stack_mode", dest="stack_mode", action="store_true",
-                        help="<optional> Whether to save stack info.", required=False)
-    parser.add_argument("-c", "--compare_only", dest="compare_only", action="store_true",
-                        help="<optional> Whether to give advisor.", required=False)
-    parser.add_argument("-f", "--fuzzy_match", dest="fuzzy_match", action="store_true",
+    parser.add_argument("-fm", "--fuzzy_match", dest="fuzzy_match", action="store_true",
                         help="<optional> Whether to perform a fuzzy match on the api name.", required=False)
-    parser.add_argument("-hl", "--highlight", dest="highlight", action="store_true",
-                        help="<optional> Whether to set result highlighting.", required=False)
     parser.add_argument("-cm", "--cell_mapping", dest="cell_mapping", type=str, nargs='?', const=True,
                         help="<optional> The cell mapping file path.", required=False)
     parser.add_argument("-am", "--api_mapping", dest="api_mapping", type=str, nargs='?', const=True,
@@ -673,12 +684,41 @@ def _compare_parser(parser):
                         help="<optional> The layer mapping file path.", required=False)
     parser.add_argument("-da", "--diff_analyze", dest="diff_analyze", action="store_true",
                         help="<optional> Whether to perform a diff analyze on the api name.", required=False)
+    parser.add_argument("-tensor_log", "--is_print_compare_log", dest="is_print_compare_log", action="store_true",
+                        help="<Optional> whether print compare log for compare auto mode task.", required=False)
+    parser.add_argument("-fr", "--fusion_rule_file", dest="fusion_rule_file", type=str, default="",
+                        help="<Optional> The fusion rule file path.", required=False)
+    parser.add_argument("-qfr", "--quant_fusion_rule_file", dest="quant_fusion_rule_file", type=str, default="",
+                        help="<Optional> The quant fusion rule file path.", required=False)
+    parser.add_argument("-cfr", "--close_fusion_rule_file", dest="close_fusion_rule_file", type=str, default="",
+                        help="<Optional> The close fusion rule file path.", required=False)
+    # rank：ms静态图比对、推理离线模型一键式比对
+    parser.add_argument("--rank", dest="rank", type=str, required=False,
+                        help="<optional> Ranks to compare when compare kernel of MindSpore for <compare auto>. "
+                             "Ranks to compare for <torchair dumps>. "
+                             "Input rank ID [0, 255] for <compare offline_model>.")
+    parser.add_argument("--step", dest="step", type=str, required=False,
+                        help="<optional> Steps to compare when compare kernel of MindSpore.")
+    parser.add_argument('--input_data', dest="input_data", default='',
+                        help='The input data path of the model. Separate multiple inputs with commas(,).'
+                             ' E.g: input_0.bin,input_1.bin')
+    parser.add_argument('--input_shape', dest="input_shape", default='',
+                        help="Shape of input shape. Separate multiple nodes with semicolons(;)."
+                             " E.g: \"input_name1:1,224,224,3;input_name2:3,300\"")
+    parser.add_argument('--output_size', dest="output_size", default='',
+                        help='The size of output. Separate multiple sizes with commas(,). E.g: 10200,34000')
+    parser.add_argument('--dym_shape_range', dest="dym_shape_range", default='',
+                        help="Dynamic shape range using in dynamic model, using this means ignore input_shape."
+                             " E.g: \"input_name1:1,3,200\~224,224-230;input_name2:1,300\"")
+    parser.add_argument('-ofs', '--onnx_fusion_switch', dest="onnx_fusion_switch", default=True,
+                        help='Onnxruntime fusion switch, set False for dump complete onnx data when necessary. '
+                             'Usage: -ofs False')
 
 
 def get_sorted_ranks(npu_dump_dir, bench_dump_dir):
     """
     get the ranks and match by order
-    """
+    """ 
     unsorted_npu_ranks = check_and_return_dir_contents(npu_dump_dir, 'rank')
     unsorted_bench_ranks = check_and_return_dir_contents(bench_dump_dir, 'rank')
     # 正则匹配已经校验rank后面必是数字，或者无数字的rank
@@ -738,6 +778,7 @@ def mp_logger_init(ranks_str):
     def wrap_logger(fn):
         def inner(msg, *args, **kwargs):
             return fn(ranks_str + msg, *args, **kwargs)
+
         return inner
 
     logger.info = wrap_logger(logger.info)
@@ -767,7 +808,7 @@ def compare_entry(compare_func, input_param, output_path, nr, kwargs):
             logger.error(f"Invalid or missing 'task' in dump.json. Skipping {nr} comparison.")
 
 
-def compare_distributed_inner(npu_dump_dir, bench_dump_dir, output_path, compare_func, **kwargs):
+def compare_distributed_inner(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
     def extract_compare_param(_file_type):
         npu_data_dir = os.path.join(npu_dump_dir, nr)
         bench_data_dir = os.path.join(bench_dump_dir, br)
@@ -777,9 +818,9 @@ def compare_distributed_inner(npu_dump_dir, bench_dump_dir, output_path, compare
             logger.debug(f'Did not find paired {_file_type} in {nr} and {br}, skip comparing.')
             return {}, True
         _input_param = {
-            'npu_json_path': npu_path,
-            'bench_json_path': bench_path,
-            'is_print_compare_log': kwargs.get('is_print_compare_log', True)
+            'npu_path': npu_path,
+            'bench_path': bench_path,
+            'is_print_compare_log': kwargs.get('is_print_compare_log', False)
         }
         return _input_param, False
 
@@ -812,22 +853,72 @@ def compare_distributed_inner(npu_dump_dir, bench_dump_dir, output_path, compare
 
     dump_data = load_json(pre_check_dump_path)
 
+    compare_framework = dump_data.get("framework", None)
+    if compare_framework == Const.PT_FRAMEWORK:
+        from msprobe.pytorch.compare.pt_compare import pt_compare
+        compare_func = pt_compare
+    elif compare_framework == Const.MS_FRAMEWORK:
+        from msprobe.mindspore.compare.ms_compare import ms_compare
+        compare_func = ms_compare
+    else:
+        logger.error(f"Unrecognized framework, now is {compare_framework}, please check dump.json.")
+        raise CompareException(CompareException.INVALID_TASK_ERROR)
+
+    compare_json_file_type = Const.DUMP_JSON_FILE
+    if dump_data.get('level') == Const.LEVEL_DEBUG:
+        compare_json_file_type = Const.DEBUG_JSON_FILE
     # ------------------统计量、md5比对------------------
     if dump_data.get('task') == Const.STATISTICS:
         # dump数据为统计量或md5时，多进程加速比对
         input_param_nr_list = []
         for nr, br in zip(npu_ranks, bench_ranks):
-            for file_type in [Const.DUMP_JSON_FILE, Const.DEBUG_JSON_FILE]:
-                input_param, skip = extract_compare_param(file_type)
-                if not skip:
-                    input_param_nr_list.append((input_param, nr))
+            input_param, skip = extract_compare_param(compare_json_file_type)
+            if not skip:
+                input_param_nr_list.append((input_param, nr))
         func_args = (compare_func, input_param_nr_list, output_path, kwargs)
         multi_statistics_compare(multi_ranks_compare, func_args)
         return
 
     # ------------------真实数据比对------------------
     for nr, br in zip(npu_ranks, bench_ranks):
-        for file_type in [Const.DUMP_JSON_FILE, Const.DEBUG_JSON_FILE]:
-            input_param, skip = extract_compare_param(file_type)
-            if not skip:
-                compare_entry(compare_func, input_param, output_path, nr, kwargs)
+        input_param, skip = extract_compare_param(compare_json_file_type)
+        if not skip:
+            compare_entry(compare_func, input_param, output_path, nr, kwargs)
+
+
+def check_input_param_path(input_param):
+    npu_path = input_param.get("npu_path", None)
+    bench_path = input_param.get("bench_path", None)
+    check_file_or_directory_path(npu_path)
+    check_file_or_directory_path(bench_path)
+
+
+def get_compare_framework(target_path, golden_path):
+    target_dump_json_content = load_json(target_path)
+    golden_dump_json_content = load_json(golden_path)
+    target_framework = target_dump_json_content.get("framework", None)
+    golden_framework = golden_dump_json_content.get("framework", None)
+    if target_framework == Const.PT_FRAMEWORK and golden_framework == Const.PT_FRAMEWORK:
+        frame_name = Const.PT_FRAMEWORK
+    elif (target_framework in [Const.MS_FRAMEWORK, Const.MT_FRAMEWORK] and
+          golden_framework in [Const.PT_FRAMEWORK, Const.MS_FRAMEWORK]):
+        frame_name = Const.MS_FRAMEWORK
+    else:
+        logger.error(f"Unrecognized framework, target now is {target_framework}, golden now is {golden_framework},"
+                     f" please check dump.json.")
+        raise CompareException(CompareException.INVALID_TASK_ERROR)
+    return frame_name
+
+
+def check_input_param_path_and_framework(args, target_framework):
+    compare_framework = get_compare_framework(args.target_path, args.golden_path)
+    if compare_framework != target_framework:
+        logger.error(f"Expected frame to be {target_framework}, actual is {compare_framework}, please check dump.json.")
+        raise CompareException(CompareException.INVALID_TASK_ERROR)
+
+    if target_framework == Const.PT_FRAMEWORK and not is_module_available("torch"):
+        logger.error("PyTorch does not exist, please install PyTorch library")
+        raise Exception("PyTorch does not exist, please install PyTorch library")
+    if target_framework == Const.MS_FRAMEWORK and not is_module_available("mindspore"):
+        logger.error("MindSpore does not exist, please install MindSpore library")
+        raise Exception("MindSpore does not exist, please install MindSpore library")

msprobe/core/config_check/__init__.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import msprobe.core.config_check.checkers
 from msprobe.core.config_check.config_checker import ConfigChecker