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

msprobe/mindspore/api_accuracy_checker/checker_support_api.yaml

@@ -0,0 +1,77 @@
+# Copyright 2024 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+# ============================================================================
+
+# list of api that can be checked
+
+tensor:
+  - add_
+  - add
+  - addmm_
+  - all
+  - allclose
+  - any
+  - bool
+  - byte
+  - ceil
+  - clamp
+  - contiguous
+  - copy_
+  - cos
+  - clone
+  - cumprod
+  - expand_as
+  - flatten
+  - float
+  - half
+  - int
+  - is_contiguous
+  - isnan
+  - item
+  - log
+  - log2
+  - long
+  - masked_fill
+  - max
+  - mean
+  - min
+  - numel
+  - numpy
+  - repeat
+  - repeat_interleave
+  - reshape
+  - round
+  - select
+  - sin
+  - size
+  - split
+  - sqrt
+  - square
+  - sub
+  - swapaxes
+  - to
+  - t
+  - tolist
+  - topk
+  - transpose
+  - trunc
+  - type
+  - unsqueeze
+  - view
+  - view_as
+  - fill_
+  - floor_
+  - clamp_
+  - type_as
+  - zero_

msprobe/mindspore/api_accuracy_checker/cmd_parser.py

@@ -1,6 +1,69 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+import argparse
+import os
+
+from msprobe.core.common.file_utils import check_file_or_directory_path, create_directory
+from msprobe.core.common.utils import Const, MsprobeBaseException
+
+
+class UniqueDeviceAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        unique_values = set(values)
+        if len(values) != len(unique_values):
+            parser.error("device id must be unique")
+        for device_id in values:
+            if not 0 <= device_id <= 4095:
+                parser.error(f"the argument 'device_id' must be in range [0, 4095], but got {device_id}")
+        setattr(namespace, self.dest, values)
+
+
 def add_api_accuracy_checker_argument(parser):
     parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", type=str, required=True,
                         help="<Required> The api param tool result file: generate from api param tool, "
                              "a json file.")
     parser.add_argument("-o", "--out_path", dest="out_path", default="./", type=str, required=False,
-                        help="<optional> The ut task result out path.")
+                        help="<optional> The ut task result out path.")
+    parser.add_argument("-csv_path", "--result_csv_path", dest="result_csv_path", default="", type=str, required=False,
+                        help="<optional> the exit csv for continue")
+
+
+def multi_add_api_accuracy_checker_argument(parser):
+    parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", type=str, required=True,
+                        help="<Required> The api param tool result file: generate from api param tool, "
+                             "a json file.")
+    parser.add_argument("-o", "--out_path", dest="out_path", default="./", type=str, required=False,
+                        help="<optional> The ut task result out path.")
+    parser.add_argument("-csv_path", "--result_csv_path", dest="result_csv_path", default="", type=str, required=False,
+                        help="<optional> the exit csv for continue")
+    #以下属于多线程参数
+    parser.add_argument("-d", "--device", dest="device_id", nargs='+', type=int,
+                        help="<optional> set device id to run ut, must be unique and in range 0-7",
+                        default=[0], required=False, action=UniqueDeviceAction)
+
+
+def check_args(args):
+    args.api_info_file = os.path.abspath(args.api_info_file)
+    check_file_or_directory_path(args.api_info_file)
+
+    if args.out_path == "":
+        args.out_path = "./"
+    args.out_path = os.path.abspath(args.out_path)
+    create_directory(args.out_path)
+
+    if args.result_csv_path:
+        args.result_csv_path = os.path.abspath(args.result_csv_path)
+        check_file_or_directory_path(args.result_csv_path)

msprobe/mindspore/api_accuracy_checker/compute_element.py

@@ -1,21 +1,37 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
 import os
 
 import mindspore
-import torch
 import numpy as np
-
-from msprobe.mindspore.common.log import logger
+import torch
+from mindspore._c_expression import typing
+from msprobe.core.common.const import Const
 from msprobe.core.common.exceptions import ApiAccuracyCheckerException
 from msprobe.core.common.file_utils import load_npy
-from msprobe.mindspore.api_accuracy_checker.type_mapping import (dtype_str_to_np_dtype, api_info_type_str_to_type,
+from msprobe.mindspore.api_accuracy_checker.type_mapping import (api_info_type_str_to_type,
                                                                  ms_dtype_to_dtype_str, torch_dtype_to_dtype_str,
                                                                  dtype_str_to_ms_dtype, dtype_str_to_np_dtype,
                                                                  dtype_str_to_torch_dtype, type_to_api_info_type_str,
                                                                  DEFAULT_CONSTRUCT_NP_FLOAT_DTYPE, TUPLE_TYPE_STR,
-                                                                 MINDSPORE_TENSOR_TYPE_STR, float_dtype_str_list,
-                                                                 int_dtype_str_list)
-from msprobe.core.common.const import Const
+                                                                 MINDSPORE_TENSOR_TYPE_STR, MINDSPORE_DTYPE_TYPE_STR,
+                                                                 SLICE_TYPE_STR, TORCH_DTYPE_TYPE_STR,
+                                                                 float_dtype_str_list, int_dtype_str_list)
 from msprobe.mindspore.api_accuracy_checker.utils import check_and_get_from_json_dict, global_context
+from msprobe.mindspore.common.log import logger
 
 
 class MstensorMetaData:
@@ -26,6 +42,12 @@ class MstensorMetaData:
         self.minimum = minimum
         self.shape = shape
 
+
+class DtypeMetaData:
+    def __init__(self, dtype_str) -> None:
+        self.dtype_str = dtype_str
+
+
 class ComputeElement:
     def __init__(self, compute_element_info=None, parameter=None):
         self.supported_parameter_type = tuple(type_to_api_info_type_str.keys()) + tuple([torch.Tensor, tuple])
@@ -56,12 +78,10 @@ class ComputeElement:
         else:
             torch_dtype = dtype_str_to_torch_dtype.get(dtype_str)
 
-        if dtype_str in float_dtype_str_list:
-            middle_dtype = mindspore.float64
-        elif dtype_str in int_dtype_str_list:
+        if dtype_str in int_dtype_str_list:
             middle_dtype = mindspore.int64
         else:
-            middle_dtype = mindspore.uint64
+            middle_dtype = mindspore.float64
         np_ndarray = ms_tensor.astype(middle_dtype).numpy()
         torch_tensor = torch.from_numpy(np_ndarray).to(torch_dtype)
         return torch_tensor
@@ -84,10 +104,10 @@ class ComputeElement:
         else:
             ms_dtype = dtype_str_to_ms_dtype.get(dtype_str)
 
-        if dtype_str in float_dtype_str_list:
-            middle_dtype = torch.float64
-        elif dtype_str in int_dtype_str_list:
+        if dtype_str in int_dtype_str_list:
             middle_dtype = torch.int64
+        else:
+            middle_dtype = torch.float64
         np_ndarray = torch_tensor.to(middle_dtype, copy=True).numpy()
         ms_tensor = mindspore.Tensor.from_numpy(np_ndarray).astype(ms_dtype)
         return ms_tensor
@@ -118,6 +138,11 @@ class ComputeElement:
                           for compute_element in self.parameter])
         elif isinstance(self.parameter, self.supported_parameter_type):
             parameter_tmp = self.parameter
+        elif isinstance(self.parameter, DtypeMetaData):
+            if tensor_platform == Const.MS_FRAMEWORK:
+                parameter_tmp = dtype_str_to_ms_dtype.get(self.parameter.dtype_str)
+            else:
+                parameter_tmp = dtype_str_to_torch_dtype.get(self.parameter.dtype_str)
         elif isinstance(self.parameter, MstensorMetaData):
             mstensor_meta_data = self.parameter
             ms_dtype = dtype_str_to_ms_dtype.get(mstensor_meta_data.dtype_str)
@@ -130,13 +155,13 @@ class ComputeElement:
             parameter_tmp = mindspore.Tensor(ndarray, dtype=ms_dtype)
         else:
             err_msg = "ComputeElement.get_parameter failed: self.parameter type is not in " \
-                "(int, float, str, slice, bool, torch.Tensor, mindspore.Tensor, MstensorMetaData)"
+                      "(int, float, str, slice, bool, torch.Tensor, mindspore.Tensor, MstensorMetaData)"
             logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
 
         # if necessary, do transfer
         if not get_origin and isinstance(parameter_tmp, mindspore.Tensor) and tensor_platform == Const.PT_FRAMEWORK:
             parameter = self.transfer_to_torch_tensor(parameter_tmp)
-        elif not get_origin and isinstance(parameter_tmp, torch.Tensor) and tensor_platform ==Const.MS_FRAMEWORK:
+        elif not get_origin and isinstance(parameter_tmp, torch.Tensor) and tensor_platform == Const.MS_FRAMEWORK:
             parameter = self.transfer_to_mindspore_tensor(parameter_tmp)
         else:
             parameter = parameter_tmp
@@ -183,34 +208,38 @@ class ComputeElement:
         else:
             type_str = check_and_get_from_json_dict(compute_element_info, "type", "type field in api_info.json",
                                                     accepted_type=str, accepted_value=api_info_type_str_to_type.keys())
-
+            self.shape = tuple()
+            self.dtype_str = type_str
             if type_str == MINDSPORE_TENSOR_TYPE_STR:
                 self._init_from_mstensor_compute_element_info(compute_element_info)
-            else: # type_str in ("slice", "int", "float", "bool")
+            else:
                 value = check_and_get_from_json_dict(compute_element_info, "value", "value field in api_info.json")
-                self.shape = tuple()
-                self.dtype_str = type_str
-                self.parameter = slice(*tuple(value)) if type_str == "slice" else value
+                if type_str == MINDSPORE_DTYPE_TYPE_STR:
+                    self.parameter = DtypeMetaData(value)
+                elif type_str == SLICE_TYPE_STR:
+                    self.parameter = slice(*tuple(value))
+                else:  # type_str in ("str", "int", "float", "bool")
+                    self.parameter = value
 
     def _init_from_mstensor_compute_element_info(self, compute_element_info):
         '''
             do not load real tensor, only record meta data
         '''
         dtype_str = check_and_get_from_json_dict(compute_element_info, "dtype", "dtype field in api_info.json",
-                                            accepted_type=str, accepted_value=dtype_str_to_ms_dtype.keys())
+                                                 accepted_type=str, accepted_value=dtype_str_to_ms_dtype.keys())
         shape = check_and_get_from_json_dict(compute_element_info, "shape", "shape field in api_info.json",
-                                                accepted_type=(list,))
+                                             accepted_type=(list,))
         if global_context.get_is_constructed():
             maximum = check_and_get_from_json_dict(compute_element_info, "Max", "Max field in api_info.json",
-                                                    accepted_type=(int, float))
+                                                   accepted_type=(int, float))
             minimum = check_and_get_from_json_dict(compute_element_info, "Min", "Min field in api_info.json",
-                                                accepted_type=(int, float))
+                                                   accepted_type=(int, float))
 
             npy_path = None
         else:
             maximum, minimum = None, None
             data_name = check_and_get_from_json_dict(compute_element_info, "data_name",
-                                                "data_name field in api_info.json", accepted_type=(str,))
+                                                     "data_name field in api_info.json", accepted_type=(str,))
             npy_path = os.path.join(global_context.get_dump_data_dir(), data_name)
         mstensor_meta_data = MstensorMetaData(dtype_str, npy_path, maximum, minimum, shape)
         self.parameter = mstensor_meta_data
@@ -219,9 +248,10 @@ class ComputeElement:
 
     def _init_with_parameter(self, parameter):
         self.parameter = parameter
+        self.shape = tuple()
         if not isinstance(parameter, self.supported_parameter_type):
             err_msg = "ComputeElement._init_with_parameter failed: " \
-                "parameter type is not in (int, float, str, slice, bool, torch.Tensor, mindspore.Tensor)"
+                      "parameter type is not in (int, float, str, slice, bool, torch.Tensor, mindspore.Tensor)"
             logger.error_log_with_exp(err_msg, ApiAccuracyCheckerException(ApiAccuracyCheckerException.UnsupportType))
         if isinstance(parameter, mindspore.Tensor):
             self.shape = tuple(parameter.shape)
@@ -229,11 +259,14 @@ class ComputeElement:
         elif isinstance(parameter, torch.Tensor):
             self.shape = tuple(parameter.shape)
             self.dtype_str = torch_dtype_to_dtype_str.get(parameter.dtype)
+        elif isinstance(parameter, typing.Type):
+            self.dtype_str = MINDSPORE_DTYPE_TYPE_STR
+            self.parameter = DtypeMetaData(ms_dtype_to_dtype_str.get(parameter))
+        elif isinstance(parameter, torch.dtype):
+            self.dtype_str = TORCH_DTYPE_TYPE_STR
+            self.parameter = DtypeMetaData(torch_dtype_to_dtype_str.get(parameter))
         elif isinstance(parameter, tuple):
-            self.shape = tuple()
             self.dtype_str = TUPLE_TYPE_STR
             self.parameter = tuple([ComputeElement(parameter=param) for param in parameter])
         else:
-            self.shape = tuple()
-            self.dtype_str = \
-                TUPLE_TYPE_STR if isinstance(parameter, tuple) else type_to_api_info_type_str.get(type(parameter))
+            self.dtype_str = type_to_api_info_type_str.get(type(parameter))

msprobe/mindspore/api_accuracy_checker/data_manager.py

@@ -0,0 +1,301 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+import os
+import csv
+
+from msprobe.core.common.const import Const, CompareConst, MsCompareConst
+from msprobe.core.common.file_utils import FileOpen, create_directory, write_csv, read_csv
+from msprobe.core.common.utils import add_time_as_suffix, MsprobeBaseException
+from msprobe.mindspore.api_accuracy_checker.base_compare_algorithm import compare_algorithms
+from msprobe.core.common.file_utils import check_file_or_directory_path
+from msprobe.mindspore.common.log import logger
+
+
+class ResultCsvEntry:
+    def __init__(self) -> None:
+        self.forward_pass_status = None
+        self.backward_pass_status = None
+        self.forward_err_msg = ""
+        self.backward_err_msg = ""
+        self.overall_err_msg = None
+
+
+def write_csv_header(csv_path, header_func):
+    """如果是第一次写入，则写入 CSV 表头"""
+    header = header_func()  # 获取表头
+    logger.debug(f"Writing CSV header: {header}")
+    write_csv([header], csv_path, mode="a+")
+
+
+def get_result_csv_header():
+    """获取结果 CSV 文件的表头"""
+    return [
+        MsCompareConst.DETAIL_CSV_API_NAME,
+        MsCompareConst.RESULT_CSV_FORWARD_TEST_SUCCESS,
+        MsCompareConst.RESULT_CSV_BACKWARD_TEST_SUCCESS,
+        MsCompareConst.DETAIL_CSV_MESSAGE,
+    ]
+
+
+def get_detail_csv_header():
+    """获取详细 CSV 文件的表头"""
+    detail_csv_header_basic_info = [
+        MsCompareConst.DETAIL_CSV_API_NAME,
+        MsCompareConst.DETAIL_CSV_BENCH_DTYPE,
+        MsCompareConst.DETAIL_CSV_TESTED_DTYPE,
+        MsCompareConst.DETAIL_CSV_SHAPE,
+    ]
+    detail_csv_header_compare_result = list(compare_algorithms.keys())
+    detail_csv_header_status = [
+        MsCompareConst.DETAIL_CSV_PASS_STATUS,
+        MsCompareConst.DETAIL_CSV_MESSAGE,
+    ]
+    return detail_csv_header_basic_info + detail_csv_header_compare_result + detail_csv_header_status
+
+
+def check_csv_header(headers, required_constants, csv_path):
+    """校验 CSV 文件表头是否包含所有必需的常量"""
+    missing_constants = [const for const in required_constants if not any(const in header for header in headers)]
+
+    if missing_constants:
+        raise MsprobeBaseException(
+            MsprobeBaseException.MISSING_HEADER_ERROR,
+            f"{csv_path} 缺少以下必需的表头字段: {missing_constants}"
+        )
+
+
+class DataManager:
+    def __init__(self, csv_dir, result_csv_path):
+        self.results = {}
+        self.results_exception_skip = {}
+        self.is_first_write = True  # 标记用于添加表头
+        self.csv_dir = csv_dir
+        self.api_names_set = set()  # 存储已经出现的 API 名称的集合
+        # 如果传入了 result_csv_path，则启用断点续检
+        if result_csv_path:
+            self.resume_from_last_csv(result_csv_path)
+            self.initialize_api_names_set(result_csv_path)
+        else:
+            # 默认情况下，设置输出路径为空，等待首次写入时初始化
+            self.result_out_path = os.path.join(self.csv_dir, add_time_as_suffix(MsCompareConst.RESULT_CSV_FILE_NAME))
+            self.detail_out_path = os.path.join(
+                self.csv_dir,
+                os.path.basename(self.result_out_path).replace("result", "details")
+            )
+
+            if self.detail_out_path and os.path.exists(self.detail_out_path):
+                check_file_or_directory_path(self.detail_out_path)
+
+            if self.result_out_path and os.path.exists(self.result_out_path):
+                check_file_or_directory_path(self.result_out_path)
+
+    def initialize_api_names_set(self, result_csv_path):
+        """读取现有的 CSV 文件并存储已经出现的 API 名称到集合中"""
+        # 使用新的 read_csv 函数读取数据
+        csv_data = read_csv(result_csv_path, as_pd=False)
+
+        # 读取标题行
+        headers = csv_data[0] if csv_data else []  # 如果文件为空，则 headers 会为空
+
+        # 使用提取的表头校验函数
+        if check_csv_header(headers, get_result_csv_header(), result_csv_path):
+
+            # 获取 "API Name" 列的索引
+            api_name_index = None
+            for i, header in enumerate(headers):
+                if MsCompareConst.DETAIL_CSV_API_NAME in header:  # CSV 文件的标题行包含了字节顺序标记,所以使用通过包含方式来查找
+                    api_name_index = i
+                    break
+
+            if api_name_index is None:
+                logger.warning(f"{result_csv_path} No column contains 'API Name'.")
+                return
+
+            # 读取每一行的 API 名称
+            for row in csv_data[1:]:  # 跳过标题行，从第二行开始
+                if row and len(row) > api_name_index:
+                    api_name = row[api_name_index]
+                    if api_name:
+                        self.api_names_set.add(api_name)
+
+            logger.debug(f"Initialized API names set from existing CSV: {self.api_names_set}")
+
+    def is_unique_api(self, api_name):
+        """检查 API 名称是否唯一，如果已经存在则返回 False，否则加入集合并返回 True"""
+        if api_name in self.api_names_set:
+            return False
+        self.api_names_set.add(api_name)
+        return True
+
+    def resume_from_last_csv(self, result_csv_path):
+        """从上次运行的 result_csv_path 恢复断点"""
+        # 获取上次的目录路径
+        last_dir = os.path.dirname(result_csv_path)
+
+        # 设置当前目录和输出路径，确保在首次写入时使用
+        self.csv_dir = last_dir
+        self.detail_out_path = os.path.join(last_dir, os.path.basename(result_csv_path).replace("result", "details"))
+        if self.detail_out_path and os.path.exists(self.detail_out_path):
+            check_file_or_directory_path(self.detail_out_path)
+        self.result_out_path = result_csv_path
+        self.is_first_write = False
+
+    def save_results(self, api_name_str):
+        if self.is_first_write:
+            # 直接写入表头
+            logger.info("Writing CSV headers for the first time.")
+            write_csv_header(self.detail_out_path, get_detail_csv_header)
+            write_csv_header(self.result_out_path, get_result_csv_header)
+            self.is_first_write = False  # 写入后标记为 False，避免重复写入表头
+
+        """写入详细输出和结果摘要并清理结果"""
+        logger.debug("Starting to write detailed output to CSV.")
+        self.to_detail_csv(self.detail_out_path)
+        logger.debug(f"Detailed output for {api_name_str} written to {self.detail_out_path}.")
+
+        logger.debug("Starting to write result summary to CSV.")
+        self.to_result_csv(self.result_out_path)
+        logger.debug(f"Result summary for {api_name_str} written to {self.result_out_path}.")
+
+        # 清理记录，准备下一次调用
+        self.clear_results()
+
+    def record(self, output_list):
+        if output_list is None:
+            return
+        for output in output_list:
+            api_real_name, forward_or_backward, basic_info, compare_result_dict = output
+            key = (api_real_name, forward_or_backward)
+            if key not in self.results:
+                self.results[key] = []
+            self.results[key].append((basic_info, compare_result_dict))
+            logger.debug(f"Updated self.results for key {key}: {self.results[key]}")
+        logger.debug(f"Complete self.results after recording: {self.results}")
+
+    def record_exception_skip(self, api_name, forward_or_backward, err_msg):
+        '''
+            record exception_skip infomation into self.record_exception_skip.
+            self.record_exception_skip: dict{str: dict{"forward": str/None, "backward": str/None}}
+            string in key is api_name, string in value is err_msg
+        '''
+        if api_name not in self.results_exception_skip:
+            self.results_exception_skip[api_name] = {Const.FORWARD: None, Const.BACKWARD: None}
+        self.results_exception_skip[api_name][forward_or_backward] = err_msg
+
+    def clear_results(self):
+        """清空 self.results 数据"""
+        logger.debug("Clearing self.results data.")
+        self.results.clear()
+        self.results_exception_skip.clear()
+
+    def to_detail_csv(self, csv_path):
+        logger.debug("Preparing detail CSV headers and rows.")
+        detail_csv = []
+
+        detail_csv_header_compare_result = list(compare_algorithms.keys())
+
+        for _, results in self.results.items():
+            for res in results:
+                basic_info, compare_result_dict = res
+                csv_row_basic_info = [
+                    basic_info.api_name,
+                    basic_info.bench_dtype,
+                    basic_info.tested_dtype,
+                    basic_info.shape
+                ]
+                csv_row_compare_result = [
+                    compare_result_dict.get(algorithm_name).compare_value
+                    for algorithm_name in detail_csv_header_compare_result
+                ]
+                csv_row_status = [basic_info.status, basic_info.err_msg]
+                csv_row = csv_row_basic_info + csv_row_compare_result + csv_row_status
+                detail_csv.append(csv_row)
+                logger.debug(f"Detail CSV row added: {csv_row}")
+
+        logger.debug(f"Writing detail CSV to {csv_path}.")
+        write_csv(detail_csv, csv_path, mode="a+")
+        logger.debug(f"Detail CSV written successfully to {csv_path}.")
+
+    def to_result_csv(self, csv_path):
+        '''
+            depend on both self.results and self.results_exception_skip
+        '''
+        logger.debug("Preparing result CSV data.")
+        result_csv = []
+
+        result_csv_dict = {}
+        for key, results in self.results.items():
+            api_real_name, forward_or_backward = key
+            pass_status = CompareConst.PASS
+            overall_err_msg = ""
+
+            for res in results:
+                basic_info, _ = res
+                if basic_info.status != CompareConst.PASS:
+                    pass_status = CompareConst.ERROR
+                overall_err_msg += basic_info.err_msg
+
+            overall_err_msg = "" if pass_status == CompareConst.PASS else overall_err_msg
+
+            if api_real_name not in result_csv_dict:
+                result_csv_dict[api_real_name] = ResultCsvEntry()
+            if forward_or_backward == Const.FORWARD:
+                result_csv_dict[api_real_name].forward_pass_status = pass_status
+                result_csv_dict[api_real_name].forward_err_msg = overall_err_msg
+            else:
+                result_csv_dict[api_real_name].backward_pass_status = pass_status
+                result_csv_dict[api_real_name].backward_err_msg = overall_err_msg
+
+        for api_name, entry in result_csv_dict.items():
+            overall_err_msg = "" if (entry.forward_pass_status == CompareConst.PASS and
+                                     entry.backward_pass_status == CompareConst.PASS) else \
+                entry.forward_err_msg + entry.backward_err_msg
+            row = [
+                api_name,
+                entry.forward_pass_status,
+                entry.backward_pass_status,
+                overall_err_msg
+            ]
+            # change row if this api has excption_skip infomation
+            if api_name in self.results_exception_skip:
+                if self.results_exception_skip[api_name][Const.FORWARD] is not None:
+                    row[1] = CompareConst.SKIP
+                    row[-1] += self.results_exception_skip[api_name][Const.FORWARD]
+                if self.results_exception_skip[api_name][Const.BACKWARD] is not None:
+                    row[2] = CompareConst.SKIP
+                    row[-1] += self.results_exception_skip[api_name][Const.BACKWARD]
+                del self.results_exception_skip[api_name]
+            result_csv.append(row)
+            logger.debug(f"Result CSV row added: {row}")
+        for api_name in self.results_exception_skip:
+            current_exception_skip = self.results_exception_skip[api_name]
+            forward_status = None
+            backward_status = None
+            err_msg = ""
+            if current_exception_skip[Const.FORWARD] is not None:
+                forward_status = CompareConst.SKIP
+                err_msg += current_exception_skip[Const.FORWARD]
+            if current_exception_skip[Const.BACKWARD] is not None:
+                backward_status = CompareConst.SKIP
+                err_msg += current_exception_skip[Const.BACKWARD]
+            row = [api_name, forward_status, backward_status, err_msg]
+            result_csv.append(row)
+
+        write_csv(result_csv, csv_path, mode="a+")
+        logger.debug(f"Result CSV written successfully to {csv_path}.")
+
+        # 设置标记为 False，防止后续重复添加表头
+        self.is_first_write = False

msprobe/mindspore/api_accuracy_checker/main.py

@@ -1,9 +1,34 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
 from msprobe.mindspore.api_accuracy_checker.api_accuracy_checker import ApiAccuracyChecker
 
+from msprobe.mindspore.api_accuracy_checker.multi_api_accuracy_checker import MultiApiAccuracyChecker
+
+from msprobe.mindspore.api_accuracy_checker.cmd_parser import check_args
+
 
 def api_checker_main(args):
-    api_accuracy_checker = ApiAccuracyChecker()
+    check_args(args)
+    api_accuracy_checker = ApiAccuracyChecker(args)
+    api_accuracy_checker.parse(args.api_info_file)
+    api_accuracy_checker.run_and_compare()
+
+
+def mul_api_checker_main(args):
+    check_args(args)
+    api_accuracy_checker = MultiApiAccuracyChecker(args)
     api_accuracy_checker.parse(args.api_info_file)
     api_accuracy_checker.run_and_compare()
-    api_accuracy_checker.to_detail_csv(args.out_path)
-    api_accuracy_checker.to_result_csv(args.out_path)