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

msprobe/core/compare/check.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");
@@ -16,8 +16,7 @@
 from msprobe.core.common.log import logger
 from msprobe.core.compare.utils import rename_api
 from msprobe.core.common.utils import check_op_str_pattern_valid, CompareException
-from msprobe.core.common.const import Const
-
+from msprobe.core.common.const import CompareConst, Const
 
 dtype_mapping = {
     "Int8": "torch.int8",
@@ -35,37 +34,43 @@ dtype_mapping = {
     "BFloat16": "torch.bfloat16",
     "Complex64": "torch.complex64",
     "Complex128": "torch.complex128"
-    }
+}
+
 
+def compare_op_dict_struct(npu_dict, bench_dict):
+    return all(npu_dict.get(key) == bench_dict.get(key) for key in CompareConst.STRUCT_COMPARE_KEY)
 
-def check_struct_match(npu_dict, bench_dict, cross_frame=False):
-    npu_struct_in = npu_dict.get("input_struct")
-    bench_struct_in = bench_dict.get("input_struct")
-    npu_struct_out = npu_dict.get("output_struct")
-    bench_struct_out = bench_dict.get("output_struct")
 
-    if cross_frame:
-        npu_struct_in = [(dtype_mapping.get(item[0], item[0]), item[1]) for item in npu_struct_in]
-        npu_struct_out = [(dtype_mapping.get(item[0], item[0]), item[1]) for item in npu_struct_out]
-    is_match = npu_struct_in == bench_struct_in and npu_struct_out == bench_struct_out
+def check_struct_match(npu_dict, bench_dict):
+    is_match = compare_op_dict_struct(npu_dict, bench_dict)
     if not is_match:
-        if len(npu_struct_in) == 0 or len(bench_struct_in) == 0 or len(npu_struct_in) != len(bench_struct_in):
-            return False
+        struct_match_list = []
         try:
-            struct_in_is_match = check_type_shape_match(npu_struct_in, bench_struct_in)
-            struct_out_is_match = check_type_shape_match(npu_struct_out, bench_struct_out)
+            for i, key in enumerate(CompareConst.STRUCT_COMPARE_KEY):
+                # 首先额外检查input_struct是否空，input_struct不可能为空
+                if i == 0 and (not npu_dict.get(key, []) or not bench_dict.get(key, [])):
+                    return False
+                struct_match_list.append(check_type_shape_match(npu_dict.get(key, []), bench_dict.get(key, [])))
         except CompareException as error:
             err_msg = f'index out of bounds error occurs in npu or bench api, please check!\n' \
                       f'npu_dict: {npu_dict}' \
                       f'bench_dict: {bench_dict}'
             logger.error(err_msg)
             raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from error
-        is_match = struct_in_is_match and struct_out_is_match
+        is_match = all(struct_match_list)
     return is_match
 
 
 def check_type_shape_match(npu_struct, bench_struct):
-    shape_type_match = False
+    """
+    further check dtypes with a dtype mapping list when dtypes are not entirely consistent.
+    """
+    if len(npu_struct) != len(bench_struct):
+        return False
+    if not npu_struct and not bench_struct:
+        return True
+
+    struct_match = False
     for npu_type_shape, bench_type_shape in zip(npu_struct, bench_struct):
         try:
             npu_type = npu_type_shape[0]
@@ -79,22 +84,14 @@ def check_type_shape_match(npu_struct, bench_struct):
         shape_match = npu_shape == bench_shape
         type_match = npu_type == bench_type
         if not type_match:
-            ms_type = [
-                [Const.FLOAT16, Const.FLOAT32], [Const.FLOAT32, Const.FLOAT16],
-                [Const.FLOAT16, Const.BFLOAT16], [Const.BFLOAT16, Const.FLOAT16]
-            ]
-            torch_type = [
-                [Const.TORCH_FLOAT16, Const.TORCH_FLOAT32], [Const.TORCH_FLOAT32, Const.TORCH_FLOAT16],
-                [Const.TORCH_FLOAT16, Const.TORCH_BFLOAT16], [Const.TORCH_BFLOAT16, Const.TORCH_FLOAT16]
-            ]
-            if ([npu_type, bench_type] in ms_type) or ([npu_type, bench_type] in torch_type):
+            if ([npu_type, bench_type] in CompareConst.MS_TYPE) or ([npu_type, bench_type] in CompareConst.TORCH_TYPE):
                 type_match = True
             else:
                 type_match = False
-        shape_type_match = shape_match and type_match
-        if not shape_type_match:
+        struct_match = shape_match and type_match
+        if not struct_match:
             return False
-    return shape_type_match
+    return struct_match
 
 
 def check_graph_mode(a_op_name, b_op_name):
@@ -106,6 +103,8 @@ def check_graph_mode(a_op_name, b_op_name):
 
 
 def fuzzy_check_op(npu_name_list, bench_name_list):
+    # 先检查api里的item长度是否相等，如果不是parameters_grad, 必然有input或者output，长度不可能为0
+    # 如果是parameters_grad, "parameters_grad"字段的字典不会是空字典，因此len>=1
     if len(npu_name_list) == 0 or len(bench_name_list) == 0 or len(npu_name_list) != len(bench_name_list):
         return False
     is_match = True
@@ -151,11 +150,11 @@ def check_json_key_value(input_output, op_name, depth=0):
         return
     if isinstance(input_output, list):
         for item in input_output:
-            check_json_key_value(item, op_name, depth+1)
+            check_json_key_value(item, op_name, depth + 1)
     elif isinstance(input_output, dict):
         for key, value in input_output.items():
             if isinstance(value, dict):
-                check_json_key_value(value, op_name, depth+1)
+                check_json_key_value(value, op_name, depth + 1)
             else:
                 valid_key_value(key, value, op_name)
 

msprobe/core/compare/compare_cli.py

@@ -14,17 +14,22 @@
 # limitations under the License.
 
 import json
-from msprobe.core.common.file_utils import FileOpen, check_file_type
+from msprobe.core.common.file_utils import check_file_type, load_json
 from msprobe.core.common.const import FileCheckConst, Const
 from msprobe.core.common.utils import CompareException
 from msprobe.core.common.log import logger
 
 
 def compare_cli(args):
-    with FileOpen(args.input_path, "r") as file:
-        input_param = json.load(file)
+    input_param = load_json(args.input_path)
     npu_path = input_param.get("npu_path", None)
     bench_path = input_param.get("bench_path", None)
+    if not npu_path:
+        logger.error(f"Missing npu_path in configuration file {args.input_path}, please check!")
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+    if not bench_path:
+        logger.error(f"Missing bench_path in configuration file {args.input_path}, please check!")
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
     frame_name = args.framework
     auto_analyze = not args.compare_only
     if frame_name == Const.PT_FRAMEWORK:
@@ -33,30 +38,43 @@ def compare_cli(args):
     else:
         from msprobe.mindspore.compare.ms_compare import ms_compare
         from msprobe.mindspore.compare.distributed_compare import ms_compare_distributed, ms_graph_compare
+
+    common_kwargs = {
+        "auto_analyze": auto_analyze,
+        "fuzzy_match": args.fuzzy_match,
+        "data_mapping": args.data_mapping,
+    }
+
     if check_file_type(npu_path) == FileCheckConst.FILE and check_file_type(bench_path) == FileCheckConst.FILE:
         input_param["npu_json_path"] = input_param.pop("npu_path")
         input_param["bench_json_path"] = input_param.pop("bench_path")
-        input_param["stack_json_path"] = input_param.pop("stack_path")
+        if "stack_path" not in input_param:
+            logger.warning(f"Missing stack_path in the configuration file. "
+                           f"Automatically detecting stack.json to determine whether to display NPU_Stack_Info.")
+        else:
+            input_param["stack_json_path"] = input_param.pop("stack_path")
+
         if frame_name == Const.PT_FRAMEWORK:
-            kwargs = {
-                "data_mapping": args.data_mapping
-            }
-            compare(input_param, args.output_path, stack_mode=args.stack_mode, auto_analyze=auto_analyze,
-                    fuzzy_match=args.fuzzy_match, **kwargs)
+            kwargs = {**common_kwargs, "stack_mode": args.stack_mode}
+            compare(input_param, args.output_path, **kwargs)
         else:
             kwargs = {
+                **common_kwargs,
                 "stack_mode": args.stack_mode,
-                "auto_analyze": auto_analyze,
-                "fuzzy_match": args.fuzzy_match,
                 "cell_mapping": args.cell_mapping,
                 "api_mapping": args.api_mapping,
-                "data_mapping": args.data_mapping,
                 "layer_mapping": args.layer_mapping
             }
-
             ms_compare(input_param, args.output_path, **kwargs)
     elif check_file_type(npu_path) == FileCheckConst.DIR and check_file_type(bench_path) == FileCheckConst.DIR:
-        kwargs = {"stack_mode": args.stack_mode, "auto_analyze": auto_analyze, "fuzzy_match": args.fuzzy_match}
+        kwargs = {
+            **common_kwargs,
+            "stack_mode": args.stack_mode,
+            "is_print_compare_log": input_param.get("is_print_compare_log", True),
+            "cell_mapping": args.cell_mapping,
+            "api_mapping": args.api_mapping,
+            "layer_mapping": args.layer_mapping
+        }
         if input_param.get("rank_id") is not None:
             ms_graph_compare(input_param, args.output_path)
             return