mindstudio-probe 1.2.2__py3-none-any.whl → 8.1.0__py3-none-any.whl

msprobe/docs/34.RL_collect.md

@@ -0,0 +1,92 @@
+# 强化学习数据采集
+
+## 介绍
+在强化学习训练过程中，往往存在多个模型（actor、reward、reference）和两个阶段（推理、训练），问题定界困难。
+
+本工具提供一种灵活存储强化学习训练过程中关键阶段性数据的能力，并支持对比两次采集的关键数据，以支持问题快速定界。
+
+常用关键数据示例：prompt、response、reward、log_prob、ref_log_probe、old_log_probe、kl_loss。
+
+
+## 安装教程
+
+参见 msprobe [安装教程](./01.installation.md)。
+
+## 使用说明
+
+### 数据采集
+
+用户识别脚本中需要采集数据的地方，然后通过插入代码的方式采集关键数据。
+
+当确定需要采集数据的地方，例如response，可以按如下方式对数据进行存储：
+```
+from msprobe.core import SingleSave
+SingleSave("./dump_path", fmk="pytorch")
+SingleSave.save({"response": response})
+```
+其中"./dump_path"为输出路径，没有默认值，需要自己配置；fmk可选"pytorch"或者"mindspore"，默认"pytorch"。
+
+其中"response"是可以任意指定的key，response是训练过程中的真实tensor变量。
+
+也支持一次性存储多个数据：
+```
+from msprobe.core import SingleSave
+SingleSave("./dump_path", fmk="pytorch")
+SingleSave.save({
+    "prompt": prompt,
+    "response": response
+    })
+```
+
+### 配置保存
+
+当确定需要采集数据配置json的地方，可以按如下方式对配置进行存储：
+```
+from msprobe.core import SingleSave
+SingleSave("./dump_path")
+SingleSave.save_config(configurations_json)
+```
+
+
+采集到的数据目录结构如下：
+```txt
+dump_path/
+├── data/ # 固定为data
+│   └── response/  # 关键数据名称，来自SingleSave.save的时候的key
+│           └── step0/  # step数
+│               └── rank0/   # rank数
+│                     └── micro_step0/   #micro_step数
+|                              └── response0.npy   #存储的关键数据的真实npy文件
+|                              └── response0.json  #存储的关键数据的统计量文件，包括tensor的最大、最小、均值、norm、shape
+├── configurations.json  # 配置json文件
+```
+
+### 结果比对
+
+两次采集数据之后得到dump_path1和dump_path2，可以创建一个比对脚本，例如compare.py，将两次训练的dump_path传入：
+```
+from msprobe.core import SingleComparator
+SingleComparator.compare(
+    "dump_path1", 
+    "dump_path2", 
+    "output_path")
+```
+
+会在output_path下对每种关键数据都生成excel结果表格，比如response.xlsx，形式为关键数据的名字加上.xlsx后缀。
+
+表格会体现每一个对应tensor的差异，解释：
+
+表头 | 解释 |
+|-------|---------|
+| step | 训练步数 |
+| rank | 卡号 |
+| micro_step | 梯度累计步数 |
+| id | 参数的shape |
+| shape1 | dump_path1中的数据形状 |
+| shape2 | dump_path2中的数据形状 |
+| 相同元素百分比 | 元素相同的个数占总元素个数的百分比 |
+| 首个不匹配元素索引 | 首个匹配不上的元素是第几个 |
+| 最大绝对误差 | 最大绝对误差 |
+| 最大相对误差 | 最大相对误差 |
+| 误差在千分之一内元素占比 | 误差在千分之一内元素个数占总元素个数的百分比 |
+| 误差在百分之一内元素占比 | 误差在百分之一内元素个数占总元素个数的百分比 |

msprobe/docs/35.nan_analyze.md

@@ -0,0 +1,72 @@
+# 整网首个溢出节点分析
+
+## 介绍
+在分析inf、nan的场景下，会采集多个rank下的多个step的dump数据，前面出现的异常会传播到同rank后续的节点，并通过通信算子传播到其他rank的后续节点中，因此如何分析首个nan出现的节点位置尤为重要。
+
+通过nan_analyze工具可以对pytorch的dump数据进行分析。在多卡场景下，检测到每张卡中产生inf/nan的节点。若是经过通信导致的inf/nan，可以分析并找出首个产生inf/nan的rank和节点。
+
+## 安装教程
+
+参见 msprobe [安装教程](./01.installation.md)。
+
+## 使用说明
+
+当前仅支持分析pytorch的dump数据。
+
+### 采集数据
+
+参见 [PyTorch 场景的精度数据采集](./05.data_dump_PyTorch.md)。
+
+### 执行命令
+
+```commandline
+msprobe -f pytorch nan_analyze -i dump_step_path -o output_dir_path
+```
+
+| 参数                 | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| -i 或 --input_path  | dump数据的目录。需指定到step层级，如`-i /xxx/dump/step0/` |
+| -o 或 --output_path | 输出文件的目录，可选，不填时默认在当前目录下创建 \"./output/" 目录。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+
+### 输出文件介绍
+
+当日志打印
+```
+Cannot find any anomaly node, no need to generate analyze file.
+```
+时，分析认为不存在异常节点，不生成分析文件。
+
+存在异常节点时，生成`anomaly_analyze_{timestamp}.json`文件，结构为：
+```json
+{
+  "rank_0": [  // 卡号
+    {
+      "op_name": "Tensor.op_name.0.forward",  // 节点名
+      "data_info": {
+        "input_args": [],  // input_args数据
+        "input_kwargs": {},  // input_kwargs数据
+        "output": []  // output数据
+      },
+      "construct_info": [],  // 节点层级数据
+      "stack_info": {}   // 堆栈数据
+    }
+  ]
+}
+```
+
+## 异常判定
+
+### 异常计算节点判定
+当某个计算节点的输入值正常，即Max或Min中不存在inf或nan，而输出值存在异常时认为从此节点开始产生了溢出，并有可能向后传递。
+
+### 异常通信节点判定
+通信节点按照功能分为有向节点，如`send`, `recv`, `scatter`, `gather`, `broadcast`, `reduce`等，以及无向节点，如`all_gather`, `all_reduce`, `reduce_scatter`, `all_to_all`等。
+
+对于有向节点，当src节点的input存在异常时，通常认为传入的数据中本身就存在异常，因此考虑异常节点发生在src节点所在rank的上一个或多个计算节点中；当src节点的input正常而output存在异常值，或dst节点的output存在异常值时，考虑是通信节点本身的操作产生了异常数据。
+
+对于无向节点，当节点input存在异常时，认为传入的数据中本身就存在异常，因此考虑异常节点发生在src节点所在rank的上一个或多个计算节点中；当input正常而output异常时，考虑是通信节点本身的操作产生了异常数据。
+
+### 顺序判定
+对于相连接的有向通信算子，认为src节点的异常发生早于dst节点；对于无向通信算子，认为异常是同时发生的。
+
+对于计算节点按照dump的顺序排序。

msprobe/docs/FAQ.md

@@ -58,11 +58,7 @@
 
    答：对于 fp16 的数据，CPU 会上升一个精度 fp32 去计算，这是和算子那边对齐的精度结论，CPU 用更高精度去计算会更接近真实值。
 
-6. 添加预检工具后截取操作报错：`IndexError: too many indices for tensor of dimension x` 或 `TypeError: len() of a 0-d tensor`。
-
-   答：注释工具目录 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中 Tensor: 下的 `- __getitem__`，工具会跳过采集该 API。如果是需要 dump 关键位置 API 也可以考虑根据报错堆栈信息注释引发报错的类型检查。
-
-7. Tensor 魔法函数具体对应什么操作？
+6. Tensor 魔法函数具体对应什么操作？
 
    答：
 
@@ -202,15 +198,11 @@ def npu_forward_fused_softmax(self, input_, mask):
 
    答：正常现象，dataloader 通过 raise 结束程序，堆栈信息可忽略。
 
-10. 添加 msprobe 工具后截取操作报错：`IndexError: too many indices for tensor of dimension x` 或 `TypeError: len() of a 0-d tensor`。
-
-    答：注释工具目录 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中 `Tensor: ` 下的 `- __getitem__`，工具会跳过采集该 API。如果是需要采集关键位置 API 也可以考虑根据报错堆栈信息注释引发报错的类型检查。
-
-11. 使用 msprobe 工具数据采集功能后，模型出现报错，报错信息为：`activation_func must be F.gelu` 或 `ValueError(Only support fusion of gelu and swiglu)`。
+10. 使用 msprobe 工具数据采集功能后，模型出现报错，报错信息为：`activation_func must be F.gelu` 或 `ValueError(Only support fusion of gelu and swiglu)`。
 
     答：这一类报错常见于 Megatron/MindSpeed/ModelLink 等加速库或模型仓中，原因是工具本身会封装 torch 的 API（API类型和地址会发生改变），而有些 API 在工具使能前类型和地址就已经确定，此时工具无法对这类 API 再进行封装，而加速库中会对某些 API 进行类型检查，即会把工具无法封装的原始的 API和工具封装之后的 API 进行判断，所以会报错。
     规避方式有3种：①将PrecisionDebugger的实例化放在文件的开始位置，即导包后的位置，确保所有API都被封装；②注释 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中的 `-gelu` 或者 `-silu`，工具会跳过采集该 API。③ 可以考虑根据报错堆栈信息注释引发报错的类型检查。
 
-12. 添加 msprobe 工具后触发与 AsStrided 算子相关、或者编译相关的报错，如：`Failed to compile Op [AsStrided]`。
+11. 添加 msprobe 工具后触发与 AsStrided 算子相关、或者编译相关的报错，如：`Failed to compile Op [AsStrided]`。
 
     答：注释工具目录 `mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml` 文件中 `Tensor: `下的 `-t` 和 `- transpose`。

msprobe/docs/data_dump_MindSpore/data_dump_MindSpore_baseline.md

@@ -1,6 +1,17 @@
 # MindSpore 场景的精度数据采集基线
 
-## "tensor"模式采集数据量参考基线
+## "statistics"模式（未开启md5）采集**时间**膨胀参考基线
+
+该基线为MindSpore框架下，使用"statistics"模式采集数据性能膨胀参考基线。测试了38B语言大模型在不同采集模式8卡下的性能膨胀。
+
+| 采集模式 | 无工具 (耗时) |  加工具但未使能 Dump (耗时)   | 加工具并使能 Dump (耗时) |
+|:--------:|:-------------:|:--------------------:|:----------------:|
+| L0       | ≈340 ms       |    ≈340 ms （无膨胀）     | ≈1.2 s  （膨胀3.5倍） |
+| L1       | ≈340 ms       | ≈0.7–1.2 s  （膨胀2~4倍） | ≈3.8 s   （膨胀11倍） |
+| mix      | ≈340 ms       | ≈0.7–1.2 s  （膨胀2~4倍） | ≈5.5 s  （膨胀16倍）  |
+
+
+## "tensor"模式采集**数据量**参考基线
 
 该基线为MindSpore框架下，使用"tensor"模式采集数据量参考基线。本基线测试了38B语言大模型在不同采集模式下，不同global_batch_size下，单卡和8卡下，数据量的变化。
 

msprobe/docs/data_dump_MindSpore/dynamic_graph_quick_start_example.md

@@ -51,6 +51,7 @@ debugger = PrecisionDebugger(config_path=config_path)
 
 # 设置 MindSpore 设备上下文
 context.set_context(mode=ms.PYNATIVE_MODE, device_target="Ascend", device_id=0)
+print("Context set successfully. Please wait for the training task.")
 
 # 定义卷积层
 def conv_layer(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode="valid", has_bias=True):
@@ -199,7 +200,7 @@ python alexnet_model.py
 
 ## 5. 数据分析
 
-在 `dump_path` 参数指定的路径下（本例中为 `./output`），会出现如下目录结构，后续精度数据分析操作可使用 msprobe 工具的精度预检和精度比对等功能，详细流程请参见[《msprobe使用手册》](../../README.md#2-精度预检)。：
+在 `dump_path` 参数指定的路径下（本例中为 `./output`），会出现如下目录结构，后续精度数据分析操作可使用 msprobe 工具的精度预检和精度比对等功能，详细流程请参见[《msprobe使用手册》](../../README.md#2-精度预检)。
 
 ```bash
 output/
@@ -208,4 +209,5 @@ output/
         ├── construct.json             # level为L0时，保存Cell的层级关系信息。当前场景为空
         ├── dump.json                  # 保存API前反向输入输出数据的统计量信息
         └── stack.json                 # 保存API的调用栈
+    ......
 ```

msprobe/mindspore/__init__.py

@@ -17,12 +17,12 @@ import os
 
 try:
     from msprobe.lib import _msprobe_c
-    os.environ["MS_HOOK_ENABLE"] = "on"
     os.environ["HOOK_TOOL_PATH"] = _msprobe_c.__file__
 except ImportError:
     from .common.log import logger
     logger.info("Module _msprobe_c has not been installed. L2-Dump may not work normally.")
 
 from msprobe.mindspore.debugger.precision_debugger import PrecisionDebugger
-from msprobe.mindspore.common.utils import seed_all
-from msprobe.mindspore.monitor.module_hook import TrainerMon
+from msprobe.mindspore.common.utils import seed_all, MsprobeStep, MsprobeInitStep
+from msprobe.mindspore.monitor.module_hook import TrainerMon
+from msprobe.mindspore.dump.graph_tensor_dump import save, save_grad

msprobe/mindspore/api_accuracy_checker/api_accuracy_checker.py

@@ -14,9 +14,11 @@
 # limitations under the License.
 
 import os
+from dataclasses import dataclass
+from typing import Any, Optional
 from tqdm import tqdm
-
-from msprobe.core.common.const import Const, CompareConst, MsCompareConst
+import numpy as np
+from msprobe.core.common.const import Const, CompareConst
 from msprobe.core.common.file_utils import FileOpen, create_directory, write_csv, load_json, load_yaml
 from msprobe.core.common.utils import add_time_as_suffix
 from msprobe.mindspore.api_accuracy_checker.api_info import ApiInfo
@@ -25,8 +27,12 @@ from msprobe.mindspore.api_accuracy_checker.base_compare_algorithm import compar
 from msprobe.mindspore.api_accuracy_checker.data_manager import DataManager
 from msprobe.mindspore.api_accuracy_checker.utils import (check_and_get_from_json_dict, global_context,
                                                           trim_output_compute_element_list)
+from msprobe.mindspore.common.const import MsCompareConst
 from msprobe.mindspore.common.log import logger
 from msprobe.mindspore.api_accuracy_checker import torch_mindtorch_importer
+from msprobe.core.data_dump.data_collector import build_data_collector
+from msprobe.core.common.utils import Const, print_tools_ends_info, DumpPathAggregation
+from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs
 
 cur_path = os.path.dirname(os.path.realpath(__file__))
 yaml_path = os.path.join(cur_path, MsCompareConst.SUPPORTED_API_LIST_FILE)
@@ -58,13 +64,128 @@ class ProcessResultPacket:
         self.err_msg = err_msg
 
 
+@dataclass
+class Config:
+    execution_mode: str
+    dump_path: str
+    task: str
+    level: str
+    scope: Optional[Any]
+    list: Optional[Any]
+    framework: str
+    data_mode: str
+    file_format: str
+    dump_tensor_data_dir: str
+    async_dump: bool
+    summary_mode: Optional[Any] = None
+
+
 class ApiAccuracyChecker:
     def __init__(self, args):
         self.api_infos = dict()
         self.data_manager = DataManager(args.out_path, args.result_csv_path)  # 在初始化时实例化 DataManager
+        self.save_error_data = args.save_error_data
+        if self.save_error_data:
+            config, dump_path_aggregation = self.init_save_error_data(args)
+            self.data_collector = build_data_collector(config)
+            self.data_collector.update_dump_paths(dump_path_aggregation)
+
+    @staticmethod
+    def init_save_error_data(args):
+        config = Config(
+            execution_mode="pynative",
+            dump_path=f"{args.out_path}",
+            dump_tensor_data_dir=f"{args.out_path}",
+            task="tensor",  # 任务类型,模拟保存tensor数据
+            level="L1",  # 级别
+            scope=None,  # 作用域 (None)
+            list=None,  # API 列表 (None)
+            framework=Const.MS_FRAMEWORK,  # 框架类型
+            data_mode="all",
+            file_format="npy",
+            async_dump=False
+        )
+
+        dump_dir = f"{args.out_path}"
+        dump_data_dir = os.path.join(dump_dir, "error_data")
+        create_directory(dump_data_dir)
+        dump_path_aggregation = DumpPathAggregation()
+        dump_path_aggregation.dump_file_path = os.path.join(dump_dir, "dump.json")
+        dump_path_aggregation.stack_file_path = os.path.join(dump_dir, "stack.json")
+        dump_path_aggregation.dump_tensor_data_dir = dump_data_dir
+        return config, dump_path_aggregation
+
+    @staticmethod
+    def prepare_api_input_aggregation(api_info, forward_or_backward=Const.FORWARD):
+        """
+        Args:
+            api_info: ApiInfo
+            forward_or_backward: str
+        Returns:
+            ApiInputAggregation
+        """
+        forward_inputs = api_info.get_compute_element_list(Const.FORWARD, Const.INPUT)
+        kwargs = api_info.get_kwargs()
+        if forward_or_backward == Const.FORWARD:
+            gradient_inputs = None
+        else:
+            gradient_inputs = api_info.get_compute_element_list(Const.BACKWARD, Const.INPUT)
+        return ApiInputAggregation(forward_inputs, kwargs, gradient_inputs)
 
     @staticmethod
-    def run_and_compare_helper(api_info, api_name_str, api_input_aggregation, forward_or_backward):
+    def is_api_checkable(api_name_str):
+        '''
+        Args:
+            api_name_str: str, e.g. "MintFunctional.relu.0.forward", key in data field of api_info.json
+        Returns:
+            is_checkable: bool
+        Description:
+            tell whether this api is checkable based on the key in "data" dict in api_info.json
+        '''
+        api_name_str_list = api_name_str.split(Const.SEP)
+        if len(api_name_str_list) < MsCompareConst.API_NAME_STR_LENGTH:
+            return False
+        api_type_str = api_name_str_list[0]
+        real_api_str = Const.SEP.join(api_name_str_list[1:-2])
+        api_list = load_yaml(yaml_path)
+        supported_tensor_api_list = api_list.get(MsCompareConst.SUPPORTED_TENSOR_LIST_KEY)
+        supported_fusion_api_list = MsCompareConst.SUPPORTED_FUSION_LIST
+        if api_type_str in (MsCompareConst.MINT, MsCompareConst.MINT_FUNCTIONAL) \
+                and global_context.get_framework() == Const.MS_FRAMEWORK:
+            return True
+        if api_type_str in MsCompareConst.MT_VALID_API_TYPES \
+                and global_context.get_framework() == Const.MT_FRAMEWORK:
+            return True
+        if api_type_str == MsCompareConst.TENSOR_API and real_api_str in supported_tensor_api_list \
+                and global_context.get_framework() == Const.MS_FRAMEWORK:
+            return True
+        if api_type_str == MsCompareConst.FUNCTIONAL_API and real_api_str in supported_fusion_api_list \
+                and global_context.get_framework() == Const.MS_FRAMEWORK:
+            return True
+        return False
+
+    def post_forward_hook(self, api_or_module_name, primitive_instance, args, kwargs, output):
+        self.data_collector.update_api_or_module_name(api_or_module_name)
+        module_input_output = ModuleForwardInputsOutputs(args=args, kwargs=kwargs, output=output)
+        self.data_collector.forward_data_collect_only_tensor(
+            api_or_module_name,
+            primitive_instance,
+            os.getpid(),
+            module_input_output
+        )
+
+    def backward_hook(self, api_or_module_name, module, grad_input, grad_output):
+        self.data_collector.update_api_or_module_name(api_or_module_name)
+
+        module_input_output = ModuleBackwardInputsOutputs(grad_input=grad_output, grad_output=grad_input)
+        self.data_collector.backward_data_collect_only_tensor(
+            api_or_module_name,
+            module,
+            os.getpid(),
+            module_input_output
+        )
+
+    def run_and_compare_helper(self, api_info, api_name_str, api_input_aggregation, forward_or_backward):
         """
         Args:
             api_info: ApiInfo
@@ -82,13 +203,22 @@ class ApiAccuracyChecker:
         """
         # get output
         if global_context.get_is_constructed():
-            # constructed situation, need use constructed input to run mindspore api getting tested_output
-            tested_outputs = api_runner(api_input_aggregation, api_name_str,
-                                        forward_or_backward, global_context.get_framework())
+            if forward_or_backward == Const.FORWARD:
+                tested_outputs, inputs, kwargs, forward_result_tuple = api_runner(api_input_aggregation, api_name_str,
+                                                                                  forward_or_backward,
+                                                                                  global_context.get_framework())
+            elif forward_or_backward == Const.BACKWARD:
+                tested_outputs, gradient_inputs, backward_result_tuple = api_runner(api_input_aggregation, api_name_str,
+                                                                                    forward_or_backward,
+                                                                                    global_context.get_framework())
+            else:
+                tested_outputs = api_runner(api_input_aggregation, api_name_str,
+                                            forward_or_backward, global_context.get_framework())
         else:
             tested_outputs = api_info.get_compute_element_list(forward_or_backward, Const.OUTPUT)
 
         bench_outputs = api_runner(api_input_aggregation, api_name_str, forward_or_backward, Const.PT_FRAMEWORK)
+
         tested_outputs = trim_output_compute_element_list(tested_outputs, forward_or_backward)
         bench_outputs = trim_output_compute_element_list(bench_outputs, forward_or_backward)
         if len(tested_outputs) != len(bench_outputs):
@@ -113,60 +243,26 @@ class ApiAccuracyChecker:
                     compare_result_dict.get(CompareConst.MAX_ABS_ERR).pass_status == CompareConst.PASS:
                 status = CompareConst.PASS
                 err_msg = ""
+
             else:
                 status = CompareConst.ERROR
                 err_msg = (compare_result_dict.get(CompareConst.COSINE).err_msg +
                            compare_result_dict.get(CompareConst.MAX_ABS_ERR).err_msg)
+                if forward_or_backward == Const.FORWARD and self.save_error_data \
+                        and global_context.get_is_constructed():
+                    api_name_str_backward = f"{api_name_str}{Const.SEP}{Const.FORWARD}"
+                    self.post_forward_hook(api_name_str_backward, None, inputs, kwargs, forward_result_tuple)
+
+                if forward_or_backward == Const.BACKWARD and self.save_error_data \
+                        and global_context.get_is_constructed():
+                    api_name_str_backward = f"{api_name_str}{Const.SEP}{Const.BACKWARD}"
+                    self.backward_hook(api_name_str_backward, None, gradient_inputs, backward_result_tuple)
+
             basic_info_status = \
                 BasicInfoAndStatus(api_name_with_slot, bench_dtype, tested_dtype, shape, status, err_msg)
             output_list.append(tuple([api_name_str, forward_or_backward, basic_info_status, compare_result_dict]))
         return output_list
 
-    @staticmethod
-    def prepare_api_input_aggregation(api_info, forward_or_backward=Const.FORWARD):
-        """
-        Args:
-            api_info: ApiInfo
-            forward_or_backward: str
-        Returns:
-            ApiInputAggregation
-        """
-        forward_inputs = api_info.get_compute_element_list(Const.FORWARD, Const.INPUT)
-        kwargs = api_info.get_kwargs()
-        if forward_or_backward == Const.FORWARD:
-            gradient_inputs = None
-        else:
-            gradient_inputs = api_info.get_compute_element_list(Const.BACKWARD, Const.INPUT)
-        return ApiInputAggregation(forward_inputs, kwargs, gradient_inputs)
-
-    @staticmethod
-    def is_api_checkable(api_name_str):
-        '''
-        Args:
-            api_name_str: str, e.g. "MintFunctional.relu.0.forward", key in data field of api_info.json
-        Returns:
-            is_checkable: bool
-        Description:
-            tell whether this api is checkable based on the key in "data" dict in api_info.json
-        '''
-        api_name_str_list = api_name_str.split(Const.SEP)
-        if len(api_name_str_list) < MsCompareConst.API_NAME_STR_LENGTH:
-            return False
-        api_type_str = api_name_str_list[0]
-        real_api_str = Const.SEP.join(api_name_str_list[1:-2])
-        api_list = load_yaml(yaml_path)
-        supported_tensor_api_list = api_list.get(MsCompareConst.SUPPORTED_TENSOR_LIST_KEY)
-        if api_type_str in (MsCompareConst.MINT, MsCompareConst.MINT_FUNCTIONAL) \
-                and global_context.get_framework() == Const.MS_FRAMEWORK:
-            return True
-        if api_type_str in MsCompareConst.MT_VALID_API_TYPES \
-                and global_context.get_framework() == Const.MT_FRAMEWORK:
-            return True
-        if api_type_str == MsCompareConst.TENSOR_API and real_api_str in supported_tensor_api_list \
-                and global_context.get_framework() == Const.MS_FRAMEWORK:
-            return True
-        return False
-
     def parse(self, api_info_path):
 
         api_info_dict = load_json(api_info_path)
@@ -178,9 +274,9 @@ class ApiAccuracyChecker:
                                                             MsCompareConst.TENSOR_TASK))
         try:
             framework = check_and_get_from_json_dict(api_info_dict, MsCompareConst.FRAMEWORK,
-                                                "framework field in api_info.json", accepted_type=str,
-                                                accepted_value=(Const.MS_FRAMEWORK,
-                                                                Const.MT_FRAMEWORK))
+                                                     "framework field in api_info.json", accepted_type=str,
+                                                     accepted_value=(Const.MS_FRAMEWORK,
+                                                                     Const.MT_FRAMEWORK))
         except Exception as e:
             framework = Const.MS_FRAMEWORK
             logger.warning(f"JSON parsing error in framework field: {e}")
@@ -296,4 +392,4 @@ class ApiAccuracyChecker:
             elif process_result_packet.process_status == MsCompareConst.ProcessStatus.EXCEPTION_SKIP:
                 self.data_manager.record_exception_skip(api_name_str, Const.BACKWARD, process_result_packet.err_msg)
 
-            self.data_manager.save_results(api_name_str)
+            self.data_manager.save_results(api_name_str)